<!DOCTYPE html>

<html>
<head>
  <title>underscore-esm.js</title>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  <meta name="viewport" content="width=device-width, target-densitydpi=160dpi, initial-scale=1.0; maximum-scale=1.0; user-scalable=0;">
  <link rel="stylesheet" media="all" href="docco.css" />
</head>
<body>
  <div id="container">
    <div id="background"></div>
    
    <ul class="sections">
        
          <li id="title">
              <div class="annotation">
                  <h1>underscore-esm.js</h1>
              </div>
          </li>
        
        
        
        <li id="section-1">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-1">&#182;</a>
              </div>
              <pre><code><span class="hljs-title class_">Underscore</span>.<span class="hljs-property">js</span> <span class="hljs-number">1.13</span><span class="hljs-number">.6</span>
<span class="hljs-attr">https</span>:<span class="hljs-comment">//underscorejs.org</span>
(c) <span class="hljs-number">2009</span>-<span class="hljs-number">2022</span> <span class="hljs-title class_">Jeremy</span> <span class="hljs-title class_">Ashkenas</span>, <span class="hljs-title class_">Julian</span> <span class="hljs-title class_">Gonggrijp</span>, and <span class="hljs-title class_">DocumentCloud</span> and <span class="hljs-title class_">Investigative</span> <span class="hljs-title class_">Reporters</span> &amp; <span class="hljs-title class_">Editors</span>
<span class="hljs-title class_">Underscore</span> may be freely distributed under the <span class="hljs-variable constant_">MIT</span> license.
</code></pre>

            </div>
            
        </li>
        
        
        <li id="section-2">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-2">&#182;</a>
              </div>
              <p>Current version.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> <span class="hljs-variable constant_">VERSION</span> = <span class="hljs-string">&#x27;1.13.6&#x27;</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-3">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-3">&#182;</a>
              </div>
              <p>Establish the root object, <code>window</code> (<code>self</code>) in the browser, <code>global</code>
on the server, or <code>this</code> in some virtual machines. We use <code>self</code>
instead of <code>window</code> for <code>WebWorker</code> support.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> root = (<span class="hljs-keyword">typeof</span> self == <span class="hljs-string">&#x27;object&#x27;</span> &amp;&amp; self.<span class="hljs-property">self</span> === self &amp;&amp; self) ||
          (<span class="hljs-keyword">typeof</span> <span class="hljs-variable language_">global</span> == <span class="hljs-string">&#x27;object&#x27;</span> &amp;&amp; <span class="hljs-variable language_">global</span>.<span class="hljs-property">global</span> === <span class="hljs-variable language_">global</span> &amp;&amp; <span class="hljs-variable language_">global</span>) ||
          <span class="hljs-title class_">Function</span>(<span class="hljs-string">&#x27;return this&#x27;</span>)() ||
          {};</pre></div></div>
            
        </li>
        
        
        <li id="section-4">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-4">&#182;</a>
              </div>
              <p>Save bytes in the minified (but not gzipped) version:</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> <span class="hljs-title class_">ArrayProto</span> = <span class="hljs-title class_">Array</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>, <span class="hljs-title class_">ObjProto</span> = <span class="hljs-title class_">Object</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>;
<span class="hljs-keyword">var</span> <span class="hljs-title class_">SymbolProto</span> = <span class="hljs-keyword">typeof</span> <span class="hljs-title class_">Symbol</span> !== <span class="hljs-string">&#x27;undefined&#x27;</span> ? <span class="hljs-title class_">Symbol</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> : <span class="hljs-literal">null</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-5">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-5">&#182;</a>
              </div>
              <p>Create quick reference variables for speed access to core prototypes.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> push = <span class="hljs-title class_">ArrayProto</span>.<span class="hljs-property">push</span>,
    slice = <span class="hljs-title class_">ArrayProto</span>.<span class="hljs-property">slice</span>,
    toString = <span class="hljs-title class_">ObjProto</span>.<span class="hljs-property">toString</span>,
    hasOwnProperty = <span class="hljs-title class_">ObjProto</span>.<span class="hljs-property">hasOwnProperty</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-6">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-6">&#182;</a>
              </div>
              <p>Modern feature detection.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> supportsArrayBuffer = <span class="hljs-keyword">typeof</span> <span class="hljs-title class_">ArrayBuffer</span> !== <span class="hljs-string">&#x27;undefined&#x27;</span>,
    supportsDataView = <span class="hljs-keyword">typeof</span> <span class="hljs-title class_">DataView</span> !== <span class="hljs-string">&#x27;undefined&#x27;</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-7">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-7">&#182;</a>
              </div>
              <p>All <strong>ECMAScript 5+</strong> native function implementations that we hope to use
are declared here.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> nativeIsArray = <span class="hljs-title class_">Array</span>.<span class="hljs-property">isArray</span>,
    nativeKeys = <span class="hljs-title class_">Object</span>.<span class="hljs-property">keys</span>,
    nativeCreate = <span class="hljs-title class_">Object</span>.<span class="hljs-property">create</span>,
    nativeIsView = supportsArrayBuffer &amp;&amp; <span class="hljs-title class_">ArrayBuffer</span>.<span class="hljs-property">isView</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-8">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-8">&#182;</a>
              </div>
              <p>Create references to these builtin functions because we override them.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> _isNaN = <span class="hljs-built_in">isNaN</span>,
    _isFinite = <span class="hljs-built_in">isFinite</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-9">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-9">&#182;</a>
              </div>
              <p>Keys in IE &lt; 9 that won’t be iterated by <code>for key in ...</code> and thus missed.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> hasEnumBug = !{<span class="hljs-attr">toString</span>: <span class="hljs-literal">null</span>}.<span class="hljs-title function_">propertyIsEnumerable</span>(<span class="hljs-string">&#x27;toString&#x27;</span>);
<span class="hljs-keyword">var</span> nonEnumerableProps = [<span class="hljs-string">&#x27;valueOf&#x27;</span>, <span class="hljs-string">&#x27;isPrototypeOf&#x27;</span>, <span class="hljs-string">&#x27;toString&#x27;</span>,
  <span class="hljs-string">&#x27;propertyIsEnumerable&#x27;</span>, <span class="hljs-string">&#x27;hasOwnProperty&#x27;</span>, <span class="hljs-string">&#x27;toLocaleString&#x27;</span>];</pre></div></div>
            
        </li>
        
        
        <li id="section-10">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-10">&#182;</a>
              </div>
              <p>The largest integer that can be represented exactly.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> <span class="hljs-variable constant_">MAX_ARRAY_INDEX</span> = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">pow</span>(<span class="hljs-number">2</span>, <span class="hljs-number">53</span>) - <span class="hljs-number">1</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-11">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-11">&#182;</a>
              </div>
              <p>Some functions take a variable number of arguments, or a few expected
arguments at the beginning and then a variable number of values to operate
on. This helper accumulates all remaining arguments past the function’s
argument length (or an explicit <code>startIndex</code>), into an array that becomes
the last argument. Similar to ES6’s “rest parameter”.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">restArguments</span>(<span class="hljs-params">func, startIndex</span>) {
  startIndex = startIndex == <span class="hljs-literal">null</span> ? func.<span class="hljs-property">length</span> - <span class="hljs-number">1</span> : +startIndex;
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">var</span> length = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(<span class="hljs-variable language_">arguments</span>.<span class="hljs-property">length</span> - startIndex, <span class="hljs-number">0</span>),
        rest = <span class="hljs-title class_">Array</span>(length),
        index = <span class="hljs-number">0</span>;
    <span class="hljs-keyword">for</span> (; index &lt; length; index++) {
      rest[index] = <span class="hljs-variable language_">arguments</span>[index + startIndex];
    }
    <span class="hljs-keyword">switch</span> (startIndex) {
      <span class="hljs-keyword">case</span> <span class="hljs-number">0</span>: <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, rest);
      <span class="hljs-keyword">case</span> <span class="hljs-number">1</span>: <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">arguments</span>[<span class="hljs-number">0</span>], rest);
      <span class="hljs-keyword">case</span> <span class="hljs-number">2</span>: <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">arguments</span>[<span class="hljs-number">0</span>], <span class="hljs-variable language_">arguments</span>[<span class="hljs-number">1</span>], rest);
    }
    <span class="hljs-keyword">var</span> args = <span class="hljs-title class_">Array</span>(startIndex + <span class="hljs-number">1</span>);
    <span class="hljs-keyword">for</span> (index = <span class="hljs-number">0</span>; index &lt; startIndex; index++) {
      args[index] = <span class="hljs-variable language_">arguments</span>[index];
    }
    args[startIndex] = rest;
    <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">apply</span>(<span class="hljs-variable language_">this</span>, args);
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-12">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-12">&#182;</a>
              </div>
              <p>Is a given variable an object?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isObject</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">var</span> type = <span class="hljs-keyword">typeof</span> obj;
  <span class="hljs-keyword">return</span> type === <span class="hljs-string">&#x27;function&#x27;</span> || (type === <span class="hljs-string">&#x27;object&#x27;</span> &amp;&amp; !!obj);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-13">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-13">&#182;</a>
              </div>
              <p>Is a given value equal to null?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isNull</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">return</span> obj === <span class="hljs-literal">null</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-14">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-14">&#182;</a>
              </div>
              <p>Is a given variable undefined?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isUndefined</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">return</span> obj === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-15">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-15">&#182;</a>
              </div>
              <p>Is a given value a boolean?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isBoolean</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">return</span> obj === <span class="hljs-literal">true</span> || obj === <span class="hljs-literal">false</span> || toString.<span class="hljs-title function_">call</span>(obj) === <span class="hljs-string">&#x27;[object Boolean]&#x27;</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-16">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-16">&#182;</a>
              </div>
              <p>Is a given value a DOM element?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isElement</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">return</span> !!(obj &amp;&amp; obj.<span class="hljs-property">nodeType</span> === <span class="hljs-number">1</span>);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-17">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-17">&#182;</a>
              </div>
              <p>Internal function for creating a <code>toString</code>-based type tester.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">tagTester</span>(<span class="hljs-params">name</span>) {
  <span class="hljs-keyword">var</span> tag = <span class="hljs-string">&#x27;[object &#x27;</span> + name + <span class="hljs-string">&#x27;]&#x27;</span>;
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">obj</span>) {
    <span class="hljs-keyword">return</span> toString.<span class="hljs-title function_">call</span>(obj) === tag;
  };
}

<span class="hljs-keyword">var</span> isString = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;String&#x27;</span>);

<span class="hljs-keyword">var</span> isNumber = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Number&#x27;</span>);

<span class="hljs-keyword">var</span> isDate = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Date&#x27;</span>);

<span class="hljs-keyword">var</span> isRegExp = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;RegExp&#x27;</span>);

<span class="hljs-keyword">var</span> isError = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Error&#x27;</span>);

<span class="hljs-keyword">var</span> isSymbol = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Symbol&#x27;</span>);

<span class="hljs-keyword">var</span> isArrayBuffer = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;ArrayBuffer&#x27;</span>);

<span class="hljs-keyword">var</span> isFunction = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Function&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-18">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-18">&#182;</a>
              </div>
              <p>Optimize <code>isFunction</code> if appropriate. Work around some <code>typeof</code> bugs in old
v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> nodelist = root.<span class="hljs-property">document</span> &amp;&amp; root.<span class="hljs-property">document</span>.<span class="hljs-property">childNodes</span>;
<span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> /./ != <span class="hljs-string">&#x27;function&#x27;</span> &amp;&amp; <span class="hljs-keyword">typeof</span> <span class="hljs-title class_">Int8Array</span> != <span class="hljs-string">&#x27;object&#x27;</span> &amp;&amp; <span class="hljs-keyword">typeof</span> nodelist != <span class="hljs-string">&#x27;function&#x27;</span>) {
  isFunction = <span class="hljs-keyword">function</span>(<span class="hljs-params">obj</span>) {
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">typeof</span> obj == <span class="hljs-string">&#x27;function&#x27;</span> || <span class="hljs-literal">false</span>;
  };
}

<span class="hljs-keyword">var</span> isFunction$<span class="hljs-number">1</span> = isFunction;

<span class="hljs-keyword">var</span> hasObjectTag = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Object&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-19">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-19">&#182;</a>
              </div>
              <p>In IE 10 - Edge 13, <code>DataView</code> has string tag <code>&#39;[object Object]&#39;</code>.
In IE 11, the most common among them, this problem also applies to
<code>Map</code>, <code>WeakMap</code> and <code>Set</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> hasStringTagBug = (
      supportsDataView &amp;&amp; <span class="hljs-title function_">hasObjectTag</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">8</span>)))
    ),
    isIE11 = (<span class="hljs-keyword">typeof</span> <span class="hljs-title class_">Map</span> !== <span class="hljs-string">&#x27;undefined&#x27;</span> &amp;&amp; <span class="hljs-title function_">hasObjectTag</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>));

<span class="hljs-keyword">var</span> isDataView = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;DataView&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-20">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-20">&#182;</a>
              </div>
              <p>In IE 10 - Edge 13, we need a different heuristic
to determine whether an object is a <code>DataView</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">ie10IsDataView</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">return</span> obj != <span class="hljs-literal">null</span> &amp;&amp; <span class="hljs-title function_">isFunction$1</span>(obj.<span class="hljs-property">getInt8</span>) &amp;&amp; <span class="hljs-title function_">isArrayBuffer</span>(obj.<span class="hljs-property">buffer</span>);
}

<span class="hljs-keyword">var</span> isDataView$<span class="hljs-number">1</span> = (hasStringTagBug ? ie10IsDataView : isDataView);</pre></div></div>
            
        </li>
        
        
        <li id="section-21">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-21">&#182;</a>
              </div>
              <p>Is a given value an array?
Delegates to ECMA5’s native <code>Array.isArray</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> isArray = nativeIsArray || <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Array&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-22">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-22">&#182;</a>
              </div>
              <p>Internal function to check whether <code>key</code> is an own property name of <code>obj</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">has$1</span>(<span class="hljs-params">obj, key</span>) {
  <span class="hljs-keyword">return</span> obj != <span class="hljs-literal">null</span> &amp;&amp; hasOwnProperty.<span class="hljs-title function_">call</span>(obj, key);
}

<span class="hljs-keyword">var</span> isArguments = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Arguments&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-23">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-23">&#182;</a>
              </div>
              <p>Define a fallback version of the method in browsers (ahem, IE &lt; 9), where
there isn’t any inspectable “Arguments” type.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>(<span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
  <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isArguments</span>(<span class="hljs-variable language_">arguments</span>)) {
    isArguments = <span class="hljs-keyword">function</span>(<span class="hljs-params">obj</span>) {
      <span class="hljs-keyword">return</span> <span class="hljs-title function_">has$1</span>(obj, <span class="hljs-string">&#x27;callee&#x27;</span>);
    };
  }
}());

<span class="hljs-keyword">var</span> isArguments$<span class="hljs-number">1</span> = isArguments;</pre></div></div>
            
        </li>
        
        
        <li id="section-24">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-24">&#182;</a>
              </div>
              <p>Is a given object a finite number?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isFinite$1</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">return</span> !<span class="hljs-title function_">isSymbol</span>(obj) &amp;&amp; <span class="hljs-title function_">_isFinite</span>(obj) &amp;&amp; !<span class="hljs-built_in">isNaN</span>(<span class="hljs-built_in">parseFloat</span>(obj));
}</pre></div></div>
            
        </li>
        
        
        <li id="section-25">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-25">&#182;</a>
              </div>
              <p>Is the given value <code>NaN</code>?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isNaN$1</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">isNumber</span>(obj) &amp;&amp; <span class="hljs-title function_">_isNaN</span>(obj);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-26">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-26">&#182;</a>
              </div>
              <p>Predicate-generating function. Often useful outside of Underscore.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">constant</span>(<span class="hljs-params">value</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">return</span> value;
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-27">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-27">&#182;</a>
              </div>
              <p>Common internal logic for <code>isArrayLike</code> and <code>isBufferLike</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">createSizePropertyCheck</span>(<span class="hljs-params">getSizeProperty</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">collection</span>) {
    <span class="hljs-keyword">var</span> sizeProperty = <span class="hljs-title function_">getSizeProperty</span>(collection);
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">typeof</span> sizeProperty == <span class="hljs-string">&#x27;number&#x27;</span> &amp;&amp; sizeProperty &gt;= <span class="hljs-number">0</span> &amp;&amp; sizeProperty &lt;= <span class="hljs-variable constant_">MAX_ARRAY_INDEX</span>;
  }
}</pre></div></div>
            
        </li>
        
        
        <li id="section-28">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-28">&#182;</a>
              </div>
              <p>Internal helper to generate a function to obtain property <code>key</code> from <code>obj</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">shallowProperty</span>(<span class="hljs-params">key</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">obj</span>) {
    <span class="hljs-keyword">return</span> obj == <span class="hljs-literal">null</span> ? <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> : obj[key];
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-29">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-29">&#182;</a>
              </div>
              <p>Internal helper to obtain the <code>byteLength</code> property of an object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> getByteLength = <span class="hljs-title function_">shallowProperty</span>(<span class="hljs-string">&#x27;byteLength&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-30">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-30">&#182;</a>
              </div>
              <p>Internal helper to determine whether we should spend extensive checks against
<code>ArrayBuffer</code> et al.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> isBufferLike = <span class="hljs-title function_">createSizePropertyCheck</span>(getByteLength);</pre></div></div>
            
        </li>
        
        
        <li id="section-31">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-31">&#182;</a>
              </div>
              <p>Is a given value a typed array?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> typedArrayPattern = <span class="hljs-regexp">/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/</span>;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">isTypedArray</span>(<span class="hljs-params">obj</span>) {</pre></div></div>
            
        </li>
        
        
        <li id="section-32">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-32">&#182;</a>
              </div>
              <p><code>ArrayBuffer.isView</code> is the most future-proof, so use it when available.
Otherwise, fall back on the above regular expression.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">return</span> nativeIsView ? (<span class="hljs-title function_">nativeIsView</span>(obj) &amp;&amp; !<span class="hljs-title function_">isDataView$1</span>(obj)) :
                <span class="hljs-title function_">isBufferLike</span>(obj) &amp;&amp; typedArrayPattern.<span class="hljs-title function_">test</span>(toString.<span class="hljs-title function_">call</span>(obj));
}

<span class="hljs-keyword">var</span> isTypedArray$<span class="hljs-number">1</span> = supportsArrayBuffer ? isTypedArray : <span class="hljs-title function_">constant</span>(<span class="hljs-literal">false</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-33">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-33">&#182;</a>
              </div>
              <p>Internal helper to obtain the <code>length</code> property of an object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> getLength = <span class="hljs-title function_">shallowProperty</span>(<span class="hljs-string">&#x27;length&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-34">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-34">&#182;</a>
              </div>
              <p>Internal helper to create a simple lookup structure.
<code>collectNonEnumProps</code> used to depend on <code>_.contains</code>, but this led to
circular imports. <code>emulatedSet</code> is a one-off solution that only works for
arrays of strings.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">emulatedSet</span>(<span class="hljs-params">keys</span>) {
  <span class="hljs-keyword">var</span> hash = {};
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> l = keys.<span class="hljs-property">length</span>, i = <span class="hljs-number">0</span>; i &lt; l; ++i) hash[keys[i]] = <span class="hljs-literal">true</span>;
  <span class="hljs-keyword">return</span> {
    <span class="hljs-attr">contains</span>: <span class="hljs-keyword">function</span>(<span class="hljs-params">key</span>) { <span class="hljs-keyword">return</span> hash[key] === <span class="hljs-literal">true</span>; },
    <span class="hljs-attr">push</span>: <span class="hljs-keyword">function</span>(<span class="hljs-params">key</span>) {
      hash[key] = <span class="hljs-literal">true</span>;
      <span class="hljs-keyword">return</span> keys.<span class="hljs-title function_">push</span>(key);
    }
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-35">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-35">&#182;</a>
              </div>
              <p>Internal helper. Checks <code>keys</code> for the presence of keys in IE &lt; 9 that won’t
be iterated by <code>for key in ...</code> and thus missed. Extends <code>keys</code> in place if
needed.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">collectNonEnumProps</span>(<span class="hljs-params">obj, keys</span>) {
  keys = <span class="hljs-title function_">emulatedSet</span>(keys);
  <span class="hljs-keyword">var</span> nonEnumIdx = nonEnumerableProps.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">var</span> constructor = obj.<span class="hljs-property">constructor</span>;
  <span class="hljs-keyword">var</span> proto = (<span class="hljs-title function_">isFunction$1</span>(constructor) &amp;&amp; constructor.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>) || <span class="hljs-title class_">ObjProto</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-36">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-36">&#182;</a>
              </div>
              <p>Constructor is a special case.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> prop = <span class="hljs-string">&#x27;constructor&#x27;</span>;
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">has$1</span>(obj, prop) &amp;&amp; !keys.<span class="hljs-title function_">contains</span>(prop)) keys.<span class="hljs-title function_">push</span>(prop);

  <span class="hljs-keyword">while</span> (nonEnumIdx--) {
    prop = nonEnumerableProps[nonEnumIdx];
    <span class="hljs-keyword">if</span> (prop <span class="hljs-keyword">in</span> obj &amp;&amp; obj[prop] !== proto[prop] &amp;&amp; !keys.<span class="hljs-title function_">contains</span>(prop)) {
      keys.<span class="hljs-title function_">push</span>(prop);
    }
  }
}</pre></div></div>
            
        </li>
        
        
        <li id="section-37">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-37">&#182;</a>
              </div>
              <p>Retrieve the names of an object’s own properties.
Delegates to <strong>ECMAScript 5</strong>‘s native <code>Object.keys</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">keys</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isObject</span>(obj)) <span class="hljs-keyword">return</span> [];
  <span class="hljs-keyword">if</span> (nativeKeys) <span class="hljs-keyword">return</span> <span class="hljs-title function_">nativeKeys</span>(obj);
  <span class="hljs-keyword">var</span> keys = [];
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> key <span class="hljs-keyword">in</span> obj) <span class="hljs-keyword">if</span> (<span class="hljs-title function_">has$1</span>(obj, key)) keys.<span class="hljs-title function_">push</span>(key);</pre></div></div>
            
        </li>
        
        
        <li id="section-38">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-38">&#182;</a>
              </div>
              <p>Ahem, IE &lt; 9.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (hasEnumBug) <span class="hljs-title function_">collectNonEnumProps</span>(obj, keys);
  <span class="hljs-keyword">return</span> keys;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-39">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-39">&#182;</a>
              </div>
              <p>Is a given array, string, or object empty?
An “empty” object has no enumerable own-properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isEmpty</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-40">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-40">&#182;</a>
              </div>
              <p>Skip the more expensive <code>toString</code>-based type checks if <code>obj</code> has no
<code>.length</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> length = <span class="hljs-title function_">getLength</span>(obj);
  <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> length == <span class="hljs-string">&#x27;number&#x27;</span> &amp;&amp; (
    <span class="hljs-title function_">isArray</span>(obj) || <span class="hljs-title function_">isString</span>(obj) || <span class="hljs-title function_">isArguments$1</span>(obj)
  )) <span class="hljs-keyword">return</span> length === <span class="hljs-number">0</span>;
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">getLength</span>(<span class="hljs-title function_">keys</span>(obj)) === <span class="hljs-number">0</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-41">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-41">&#182;</a>
              </div>
              <p>Returns whether an object has a given set of <code>key:value</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isMatch</span>(<span class="hljs-params">object, attrs</span>) {
  <span class="hljs-keyword">var</span> _keys = <span class="hljs-title function_">keys</span>(attrs), length = _keys.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">if</span> (object == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> !length;
  <span class="hljs-keyword">var</span> obj = <span class="hljs-title class_">Object</span>(object);
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
    <span class="hljs-keyword">var</span> key = _keys[i];
    <span class="hljs-keyword">if</span> (attrs[key] !== obj[key] || !(key <span class="hljs-keyword">in</span> obj)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
  }
  <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-42">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-42">&#182;</a>
              </div>
              <p>If Underscore is called as a function, it returns a wrapped object that can
be used OO-style. This wrapper holds altered versions of all functions added
through <code>_.mixin</code>. Wrapped objects may be chained.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">_$1</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">if</span> (obj <span class="hljs-keyword">instanceof</span> _$<span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> obj;
  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> _$<span class="hljs-number">1</span>)) <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title function_">_$1</span>(obj);
  <span class="hljs-variable language_">this</span>.<span class="hljs-property">_wrapped</span> = obj;
}

_$<span class="hljs-number">1.</span><span class="hljs-variable constant_">VERSION</span> = <span class="hljs-variable constant_">VERSION</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-43">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-43">&#182;</a>
              </div>
              <p>Extracts the result from a wrapped and chained object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>_$<span class="hljs-number">1.</span>prototype.<span class="hljs-property">value</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">_wrapped</span>;
};</pre></div></div>
            
        </li>
        
        
        <li id="section-44">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-44">&#182;</a>
              </div>
              <p>Provide unwrapping proxies for some methods used in engine operations
such as arithmetic and JSON stringification.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>_$<span class="hljs-number">1.</span>prototype.<span class="hljs-property">valueOf</span> = _$<span class="hljs-number">1.</span>prototype.<span class="hljs-property">toJSON</span> = _$<span class="hljs-number">1.</span>prototype.<span class="hljs-property">value</span>;

_$<span class="hljs-number">1.</span>prototype.<span class="hljs-property">toString</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title class_">String</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">_wrapped</span>);
};</pre></div></div>
            
        </li>
        
        
        <li id="section-45">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-45">&#182;</a>
              </div>
              <p>Internal function to wrap or shallow-copy an ArrayBuffer,
typed array or DataView to a new view, reusing the buffer.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">toBufferView</span>(<span class="hljs-params">bufferSource</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint8Array</span>(
    bufferSource.<span class="hljs-property">buffer</span> || bufferSource,
    bufferSource.<span class="hljs-property">byteOffset</span> || <span class="hljs-number">0</span>,
    <span class="hljs-title function_">getByteLength</span>(bufferSource)
  );
}</pre></div></div>
            
        </li>
        
        
        <li id="section-46">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-46">&#182;</a>
              </div>
              <p>We use this string twice, so give it a name for minification.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> tagDataView = <span class="hljs-string">&#x27;[object DataView]&#x27;</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-47">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-47">&#182;</a>
              </div>
              <p>Internal recursive comparison function for <code>_.isEqual</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">eq</span>(<span class="hljs-params">a, b, aStack, bStack</span>) {</pre></div></div>
            
        </li>
        
        
        <li id="section-48">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-48">&#182;</a>
              </div>
              <p>Identical objects are equal. <code>0 === -0</code>, but they aren’t identical.
See the <a href="https://wiki.ecmascript.org/doku.php?id=harmony:egal">Harmony <code>egal</code> proposal</a>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (a === b) <span class="hljs-keyword">return</span> a !== <span class="hljs-number">0</span> || <span class="hljs-number">1</span> / a === <span class="hljs-number">1</span> / b;</pre></div></div>
            
        </li>
        
        
        <li id="section-49">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-49">&#182;</a>
              </div>
              <p><code>null</code> or <code>undefined</code> only equal to itself (strict comparison).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (a == <span class="hljs-literal">null</span> || b == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-50">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-50">&#182;</a>
              </div>
              <p><code>NaN</code>s are equivalent, but non-reflexive.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (a !== a) <span class="hljs-keyword">return</span> b !== b;</pre></div></div>
            
        </li>
        
        
        <li id="section-51">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-51">&#182;</a>
              </div>
              <p>Exhaust primitive checks</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> type = <span class="hljs-keyword">typeof</span> a;
  <span class="hljs-keyword">if</span> (type !== <span class="hljs-string">&#x27;function&#x27;</span> &amp;&amp; type !== <span class="hljs-string">&#x27;object&#x27;</span> &amp;&amp; <span class="hljs-keyword">typeof</span> b != <span class="hljs-string">&#x27;object&#x27;</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">deepEq</span>(a, b, aStack, bStack);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-52">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-52">&#182;</a>
              </div>
              <p>Internal recursive comparison function for <code>_.isEqual</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">deepEq</span>(<span class="hljs-params">a, b, aStack, bStack</span>) {</pre></div></div>
            
        </li>
        
        
        <li id="section-53">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-53">&#182;</a>
              </div>
              <p>Unwrap any wrapped objects.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (a <span class="hljs-keyword">instanceof</span> _$<span class="hljs-number">1</span>) a = a.<span class="hljs-property">_wrapped</span>;
  <span class="hljs-keyword">if</span> (b <span class="hljs-keyword">instanceof</span> _$<span class="hljs-number">1</span>) b = b.<span class="hljs-property">_wrapped</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-54">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-54">&#182;</a>
              </div>
              <p>Compare <code>[[Class]]</code> names.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> className = toString.<span class="hljs-title function_">call</span>(a);
  <span class="hljs-keyword">if</span> (className !== toString.<span class="hljs-title function_">call</span>(b)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-55">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-55">&#182;</a>
              </div>
              <p>Work around a bug in IE 10 - Edge 13.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (hasStringTagBug &amp;&amp; className == <span class="hljs-string">&#x27;[object Object]&#x27;</span> &amp;&amp; <span class="hljs-title function_">isDataView$1</span>(a)) {
    <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isDataView$1</span>(b)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    className = tagDataView;
  }
  <span class="hljs-keyword">switch</span> (className) {</pre></div></div>
            
        </li>
        
        
        <li id="section-56">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-56">&#182;</a>
              </div>
              <p>These types are compared by value.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">case</span> <span class="hljs-string">&#x27;[object RegExp]&#x27;</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-57">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-57">&#182;</a>
              </div>
              <p>RegExps are coerced to strings for comparison (Note: ‘’ + /a/i === ‘/a/i’)</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">case</span> <span class="hljs-string">&#x27;[object String]&#x27;</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-58">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-58">&#182;</a>
              </div>
              <p>Primitives and their corresponding object wrappers are equivalent; thus, <code>&quot;5&quot;</code> is
equivalent to <code>new String(&quot;5&quot;)</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">return</span> <span class="hljs-string">&#x27;&#x27;</span> + a === <span class="hljs-string">&#x27;&#x27;</span> + b;
    <span class="hljs-keyword">case</span> <span class="hljs-string">&#x27;[object Number]&#x27;</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-59">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-59">&#182;</a>
              </div>
              <p><code>NaN</code>s are equivalent, but non-reflexive.
Object(NaN) is equivalent to NaN.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">if</span> (+a !== +a) <span class="hljs-keyword">return</span> +b !== +b;</pre></div></div>
            
        </li>
        
        
        <li id="section-60">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-60">&#182;</a>
              </div>
              <p>An <code>egal</code> comparison is performed for other numeric values.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">return</span> +a === <span class="hljs-number">0</span> ? <span class="hljs-number">1</span> / +a === <span class="hljs-number">1</span> / b : +a === +b;
    <span class="hljs-keyword">case</span> <span class="hljs-string">&#x27;[object Date]&#x27;</span>:
    <span class="hljs-keyword">case</span> <span class="hljs-string">&#x27;[object Boolean]&#x27;</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-61">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-61">&#182;</a>
              </div>
              <p>Coerce dates and booleans to numeric primitive values. Dates are compared by their
millisecond representations. Note that invalid dates with millisecond representations
of <code>NaN</code> are not equivalent.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">return</span> +a === +b;
    <span class="hljs-keyword">case</span> <span class="hljs-string">&#x27;[object Symbol]&#x27;</span>:
      <span class="hljs-keyword">return</span> <span class="hljs-title class_">SymbolProto</span>.<span class="hljs-property">valueOf</span>.<span class="hljs-title function_">call</span>(a) === <span class="hljs-title class_">SymbolProto</span>.<span class="hljs-property">valueOf</span>.<span class="hljs-title function_">call</span>(b);
    <span class="hljs-keyword">case</span> <span class="hljs-string">&#x27;[object ArrayBuffer]&#x27;</span>:
    <span class="hljs-keyword">case</span> <span class="hljs-attr">tagDataView</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-62">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-62">&#182;</a>
              </div>
              <p>Coerce to typed array so we can fall through.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">return</span> <span class="hljs-title function_">deepEq</span>(<span class="hljs-title function_">toBufferView</span>(a), <span class="hljs-title function_">toBufferView</span>(b), aStack, bStack);
  }

  <span class="hljs-keyword">var</span> areArrays = className === <span class="hljs-string">&#x27;[object Array]&#x27;</span>;
  <span class="hljs-keyword">if</span> (!areArrays &amp;&amp; <span class="hljs-title function_">isTypedArray$1</span>(a)) {
      <span class="hljs-keyword">var</span> byteLength = <span class="hljs-title function_">getByteLength</span>(a);
      <span class="hljs-keyword">if</span> (byteLength !== <span class="hljs-title function_">getByteLength</span>(b)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
      <span class="hljs-keyword">if</span> (a.<span class="hljs-property">buffer</span> === b.<span class="hljs-property">buffer</span> &amp;&amp; a.<span class="hljs-property">byteOffset</span> === b.<span class="hljs-property">byteOffset</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
      areArrays = <span class="hljs-literal">true</span>;
  }
  <span class="hljs-keyword">if</span> (!areArrays) {
    <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> a != <span class="hljs-string">&#x27;object&#x27;</span> || <span class="hljs-keyword">typeof</span> b != <span class="hljs-string">&#x27;object&#x27;</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-63">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-63">&#182;</a>
              </div>
              <p>Objects with different constructors are not equivalent, but <code>Object</code>s or <code>Array</code>s
from different frames are.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> aCtor = a.<span class="hljs-property">constructor</span>, bCtor = b.<span class="hljs-property">constructor</span>;
    <span class="hljs-keyword">if</span> (aCtor !== bCtor &amp;&amp; !(<span class="hljs-title function_">isFunction$1</span>(aCtor) &amp;&amp; aCtor <span class="hljs-keyword">instanceof</span> aCtor &amp;&amp;
                             <span class="hljs-title function_">isFunction$1</span>(bCtor) &amp;&amp; bCtor <span class="hljs-keyword">instanceof</span> bCtor)
                        &amp;&amp; (<span class="hljs-string">&#x27;constructor&#x27;</span> <span class="hljs-keyword">in</span> a &amp;&amp; <span class="hljs-string">&#x27;constructor&#x27;</span> <span class="hljs-keyword">in</span> b)) {
      <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-64">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-64">&#182;</a>
              </div>
              <p>Assume equality for cyclic structures. The algorithm for detecting cyclic
structures is adapted from ES 5.1 section 15.12.3, abstract operation <code>JO</code>.</p>

            </div>
            
        </li>
        
        
        <li id="section-65">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-65">&#182;</a>
              </div>
              <p>Initializing stack of traversed objects.
It’s done here since we only need them for objects and arrays comparison.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  aStack = aStack || [];
  bStack = bStack || [];
  <span class="hljs-keyword">var</span> length = aStack.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">while</span> (length--) {</pre></div></div>
            
        </li>
        
        
        <li id="section-66">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-66">&#182;</a>
              </div>
              <p>Linear search. Performance is inversely proportional to the number of
unique nested structures.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (aStack[length] === a) <span class="hljs-keyword">return</span> bStack[length] === b;
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-67">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-67">&#182;</a>
              </div>
              <p>Add the first object to the stack of traversed objects.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  aStack.<span class="hljs-title function_">push</span>(a);
  bStack.<span class="hljs-title function_">push</span>(b);</pre></div></div>
            
        </li>
        
        
        <li id="section-68">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-68">&#182;</a>
              </div>
              <p>Recursively compare objects and arrays.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (areArrays) {</pre></div></div>
            
        </li>
        
        
        <li id="section-69">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-69">&#182;</a>
              </div>
              <p>Compare array lengths to determine if a deep comparison is necessary.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    length = a.<span class="hljs-property">length</span>;
    <span class="hljs-keyword">if</span> (length !== b.<span class="hljs-property">length</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-70">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-70">&#182;</a>
              </div>
              <p>Deep compare the contents, ignoring non-numeric properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">while</span> (length--) {
      <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">eq</span>(a[length], b[length], aStack, bStack)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
  } <span class="hljs-keyword">else</span> {</pre></div></div>
            
        </li>
        
        
        <li id="section-71">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-71">&#182;</a>
              </div>
              <p>Deep compare objects.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> _keys = <span class="hljs-title function_">keys</span>(a), key;
    length = _keys.<span class="hljs-property">length</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-72">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-72">&#182;</a>
              </div>
              <p>Ensure that both objects contain the same number of properties before comparing deep equality.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">keys</span>(b).<span class="hljs-property">length</span> !== length) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    <span class="hljs-keyword">while</span> (length--) {</pre></div></div>
            
        </li>
        
        
        <li id="section-73">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-73">&#182;</a>
              </div>
              <p>Deep compare each member</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      key = _keys[length];
      <span class="hljs-keyword">if</span> (!(<span class="hljs-title function_">has$1</span>(b, key) &amp;&amp; <span class="hljs-title function_">eq</span>(a[key], b[key], aStack, bStack))) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-74">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-74">&#182;</a>
              </div>
              <p>Remove the first object from the stack of traversed objects.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  aStack.<span class="hljs-title function_">pop</span>();
  bStack.<span class="hljs-title function_">pop</span>();
  <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-75">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-75">&#182;</a>
              </div>
              <p>Perform a deep comparison to check if two objects are equal.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">isEqual</span>(<span class="hljs-params">a, b</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">eq</span>(a, b);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-76">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-76">&#182;</a>
              </div>
              <p>Retrieve all the enumerable property names of an object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">allKeys</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isObject</span>(obj)) <span class="hljs-keyword">return</span> [];
  <span class="hljs-keyword">var</span> keys = [];
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> key <span class="hljs-keyword">in</span> obj) keys.<span class="hljs-title function_">push</span>(key);</pre></div></div>
            
        </li>
        
        
        <li id="section-77">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-77">&#182;</a>
              </div>
              <p>Ahem, IE &lt; 9.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (hasEnumBug) <span class="hljs-title function_">collectNonEnumProps</span>(obj, keys);
  <span class="hljs-keyword">return</span> keys;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-78">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-78">&#182;</a>
              </div>
              <p>Since the regular <code>Object.prototype.toString</code> type tests don’t work for
some types in IE 11, we use a fingerprinting heuristic instead, based
on the methods. It’s not great, but it’s the best we got.
The fingerprint method lists are defined below.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">ie11fingerprint</span>(<span class="hljs-params">methods</span>) {
  <span class="hljs-keyword">var</span> length = <span class="hljs-title function_">getLength</span>(methods);
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">obj</span>) {
    <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-79">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-79">&#182;</a>
              </div>
              <p><code>Map</code>, <code>WeakMap</code> and <code>Set</code> have no enumerable keys.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> keys = <span class="hljs-title function_">allKeys</span>(obj);
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">getLength</span>(keys)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
      <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isFunction$1</span>(obj[methods[i]])) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }</pre></div></div>
            
        </li>
        
        
        <li id="section-80">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-80">&#182;</a>
              </div>
              <p>If we are testing against <code>WeakMap</code>, we need to ensure that
<code>obj</code> doesn’t have a <code>forEach</code> method in order to distinguish
it from a regular <code>Map</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">return</span> methods !== weakMapMethods || !<span class="hljs-title function_">isFunction$1</span>(obj[forEachName]);
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-81">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-81">&#182;</a>
              </div>
              <p>In the interest of compact minification, we write
each string in the fingerprints only once.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> forEachName = <span class="hljs-string">&#x27;forEach&#x27;</span>,
    hasName = <span class="hljs-string">&#x27;has&#x27;</span>,
    commonInit = [<span class="hljs-string">&#x27;clear&#x27;</span>, <span class="hljs-string">&#x27;delete&#x27;</span>],
    mapTail = [<span class="hljs-string">&#x27;get&#x27;</span>, hasName, <span class="hljs-string">&#x27;set&#x27;</span>];</pre></div></div>
            
        </li>
        
        
        <li id="section-82">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-82">&#182;</a>
              </div>
              <p><code>Map</code>, <code>WeakMap</code> and <code>Set</code> each have slightly different
combinations of the above sublists.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> mapMethods = commonInit.<span class="hljs-title function_">concat</span>(forEachName, mapTail),
    weakMapMethods = commonInit.<span class="hljs-title function_">concat</span>(mapTail),
    setMethods = [<span class="hljs-string">&#x27;add&#x27;</span>].<span class="hljs-title function_">concat</span>(commonInit, forEachName, hasName);

<span class="hljs-keyword">var</span> isMap = isIE11 ? <span class="hljs-title function_">ie11fingerprint</span>(mapMethods) : <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Map&#x27;</span>);

<span class="hljs-keyword">var</span> isWeakMap = isIE11 ? <span class="hljs-title function_">ie11fingerprint</span>(weakMapMethods) : <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;WeakMap&#x27;</span>);

<span class="hljs-keyword">var</span> isSet = isIE11 ? <span class="hljs-title function_">ie11fingerprint</span>(setMethods) : <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;Set&#x27;</span>);

<span class="hljs-keyword">var</span> isWeakSet = <span class="hljs-title function_">tagTester</span>(<span class="hljs-string">&#x27;WeakSet&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-83">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-83">&#182;</a>
              </div>
              <p>Retrieve the values of an object’s properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">values</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">var</span> _keys = <span class="hljs-title function_">keys</span>(obj);
  <span class="hljs-keyword">var</span> length = _keys.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">var</span> values = <span class="hljs-title class_">Array</span>(length);
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
    values[i] = obj[_keys[i]];
  }
  <span class="hljs-keyword">return</span> values;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-84">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-84">&#182;</a>
              </div>
              <p>Convert an object into a list of <code>[key, value]</code> pairs.
The opposite of <code>_.object</code> with one argument.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">pairs</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">var</span> _keys = <span class="hljs-title function_">keys</span>(obj);
  <span class="hljs-keyword">var</span> length = _keys.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">var</span> pairs = <span class="hljs-title class_">Array</span>(length);
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
    pairs[i] = [_keys[i], obj[_keys[i]]];
  }
  <span class="hljs-keyword">return</span> pairs;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-85">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-85">&#182;</a>
              </div>
              <p>Invert the keys and values of an object. The values must be serializable.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">invert</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">var</span> result = {};
  <span class="hljs-keyword">var</span> _keys = <span class="hljs-title function_">keys</span>(obj);
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = _keys.<span class="hljs-property">length</span>; i &lt; length; i++) {
    result[obj[_keys[i]]] = _keys[i];
  }
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-86">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-86">&#182;</a>
              </div>
              <p>Return a sorted list of the function names available on the object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">functions</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">var</span> names = [];
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> key <span class="hljs-keyword">in</span> obj) {
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isFunction$1</span>(obj[key])) names.<span class="hljs-title function_">push</span>(key);
  }
  <span class="hljs-keyword">return</span> names.<span class="hljs-title function_">sort</span>();
}</pre></div></div>
            
        </li>
        
        
        <li id="section-87">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-87">&#182;</a>
              </div>
              <p>An internal function for creating assigner functions.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">createAssigner</span>(<span class="hljs-params">keysFunc, defaults</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">obj</span>) {
    <span class="hljs-keyword">var</span> length = <span class="hljs-variable language_">arguments</span>.<span class="hljs-property">length</span>;
    <span class="hljs-keyword">if</span> (defaults) obj = <span class="hljs-title class_">Object</span>(obj);
    <span class="hljs-keyword">if</span> (length &lt; <span class="hljs-number">2</span> || obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> obj;
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">1</span>; index &lt; length; index++) {
      <span class="hljs-keyword">var</span> source = <span class="hljs-variable language_">arguments</span>[index],
          keys = <span class="hljs-title function_">keysFunc</span>(source),
          l = keys.<span class="hljs-property">length</span>;
      <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; l; i++) {
        <span class="hljs-keyword">var</span> key = keys[i];
        <span class="hljs-keyword">if</span> (!defaults || obj[key] === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) obj[key] = source[key];
      }
    }
    <span class="hljs-keyword">return</span> obj;
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-88">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-88">&#182;</a>
              </div>
              <p>Extend a given object with all the properties in passed-in object(s).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> extend = <span class="hljs-title function_">createAssigner</span>(allKeys);</pre></div></div>
            
        </li>
        
        
        <li id="section-89">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-89">&#182;</a>
              </div>
              <p>Assigns a given object with all the own properties in the passed-in
object(s).
(<a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign">https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign</a>)</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> extendOwn = <span class="hljs-title function_">createAssigner</span>(keys);</pre></div></div>
            
        </li>
        
        
        <li id="section-90">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-90">&#182;</a>
              </div>
              <p>Fill in a given object with default properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> defaults = <span class="hljs-title function_">createAssigner</span>(allKeys, <span class="hljs-literal">true</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-91">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-91">&#182;</a>
              </div>
              <p>Create a naked function reference for surrogate-prototype-swapping.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">ctor</span>(<span class="hljs-params"></span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>){};
}</pre></div></div>
            
        </li>
        
        
        <li id="section-92">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-92">&#182;</a>
              </div>
              <p>An internal function for creating a new object that inherits from another.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">baseCreate</span>(<span class="hljs-params">prototype</span>) {
  <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isObject</span>(prototype)) <span class="hljs-keyword">return</span> {};
  <span class="hljs-keyword">if</span> (nativeCreate) <span class="hljs-keyword">return</span> <span class="hljs-title function_">nativeCreate</span>(prototype);
  <span class="hljs-keyword">var</span> <span class="hljs-title class_">Ctor</span> = <span class="hljs-title function_">ctor</span>();
  <span class="hljs-title class_">Ctor</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> = prototype;
  <span class="hljs-keyword">var</span> result = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Ctor</span>;
  <span class="hljs-title class_">Ctor</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> = <span class="hljs-literal">null</span>;
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-93">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-93">&#182;</a>
              </div>
              <p>Creates an object that inherits from the given prototype object.
If additional properties are provided then they will be added to the
created object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">create</span>(<span class="hljs-params">prototype, props</span>) {
  <span class="hljs-keyword">var</span> result = <span class="hljs-title function_">baseCreate</span>(prototype);
  <span class="hljs-keyword">if</span> (props) <span class="hljs-title function_">extendOwn</span>(result, props);
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-94">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-94">&#182;</a>
              </div>
              <p>Create a (shallow-cloned) duplicate of an object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">clone</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isObject</span>(obj)) <span class="hljs-keyword">return</span> obj;
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">isArray</span>(obj) ? obj.<span class="hljs-title function_">slice</span>() : <span class="hljs-title function_">extend</span>({}, obj);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-95">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-95">&#182;</a>
              </div>
              <p>Invokes <code>interceptor</code> with the <code>obj</code> and then returns <code>obj</code>.
The primary purpose of this method is to “tap into” a method chain, in
order to perform operations on intermediate results within the chain.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">tap</span>(<span class="hljs-params">obj, interceptor</span>) {
  <span class="hljs-title function_">interceptor</span>(obj);
  <span class="hljs-keyword">return</span> obj;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-96">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-96">&#182;</a>
              </div>
              <p>Normalize a (deep) property <code>path</code> to array.
Like <code>_.iteratee</code>, this function can be customized.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">toPath$1</span>(<span class="hljs-params">path</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">isArray</span>(path) ? path : [path];
}
_$<span class="hljs-number">1.</span>toPath = toPath$<span class="hljs-number">1</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-97">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-97">&#182;</a>
              </div>
              <p>Internal wrapper for <code>_.toPath</code> to enable minification.
Similar to <code>cb</code> for <code>_.iteratee</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">toPath</span>(<span class="hljs-params">path</span>) {
  <span class="hljs-keyword">return</span> _$<span class="hljs-number">1.</span><span class="hljs-title function_">toPath</span>(path);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-98">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-98">&#182;</a>
              </div>
              <p>Internal function to obtain a nested property in <code>obj</code> along <code>path</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">deepGet</span>(<span class="hljs-params">obj, path</span>) {
  <span class="hljs-keyword">var</span> length = path.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
    <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>;
    obj = obj[path[i]];
  }
  <span class="hljs-keyword">return</span> length ? obj : <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-99">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-99">&#182;</a>
              </div>
              <p>Get the value of the (deep) property on <code>path</code> from <code>object</code>.
If any property in <code>path</code> does not exist or if the value is
<code>undefined</code>, return <code>defaultValue</code> instead.
The <code>path</code> is normalized through <code>_.toPath</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">get</span>(<span class="hljs-params">object, path, defaultValue</span>) {
  <span class="hljs-keyword">var</span> value = <span class="hljs-title function_">deepGet</span>(object, <span class="hljs-title function_">toPath</span>(path));
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">isUndefined</span>(value) ? defaultValue : value;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-100">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-100">&#182;</a>
              </div>
              <p>Shortcut function for checking if an object has a given property directly on
itself (in other words, not on a prototype). Unlike the internal <code>has</code>
function, this public version can also traverse nested properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">has</span>(<span class="hljs-params">obj, path</span>) {
  path = <span class="hljs-title function_">toPath</span>(path);
  <span class="hljs-keyword">var</span> length = path.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
    <span class="hljs-keyword">var</span> key = path[i];
    <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">has$1</span>(obj, key)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    obj = obj[key];
  }
  <span class="hljs-keyword">return</span> !!length;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-101">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-101">&#182;</a>
              </div>
              <p>Keep the identity function around for default iteratees.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">identity</span>(<span class="hljs-params">value</span>) {
  <span class="hljs-keyword">return</span> value;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-102">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-102">&#182;</a>
              </div>
              <p>Returns a predicate for checking whether an object has a given set of
<code>key:value</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">matcher</span>(<span class="hljs-params">attrs</span>) {
  attrs = <span class="hljs-title function_">extendOwn</span>({}, attrs);
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">obj</span>) {
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">isMatch</span>(obj, attrs);
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-103">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-103">&#182;</a>
              </div>
              <p>Creates a function that, when passed an object, will traverse that object’s
properties down the given <code>path</code>, specified as an array of keys or indices.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">property</span>(<span class="hljs-params">path</span>) {
  path = <span class="hljs-title function_">toPath</span>(path);
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">obj</span>) {
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">deepGet</span>(obj, path);
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-104">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-104">&#182;</a>
              </div>
              <p>Internal function that returns an efficient (for current engines) version
of the passed-in callback, to be repeatedly applied in other Underscore
functions.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">optimizeCb</span>(<span class="hljs-params">func, context, argCount</span>) {
  <span class="hljs-keyword">if</span> (context === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> func;
  <span class="hljs-keyword">switch</span> (argCount == <span class="hljs-literal">null</span> ? <span class="hljs-number">3</span> : argCount) {
    <span class="hljs-keyword">case</span> <span class="hljs-number">1</span>: <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">value</span>) {
      <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">call</span>(context, value);
    };</pre></div></div>
            
        </li>
        
        
        <li id="section-105">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-105">&#182;</a>
              </div>
              <p>The 2-argument case is omitted because we’re not using it.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">case</span> <span class="hljs-number">3</span>: <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">value, index, collection</span>) {
      <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">call</span>(context, value, index, collection);
    };
    <span class="hljs-keyword">case</span> <span class="hljs-number">4</span>: <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">accumulator, value, index, collection</span>) {
      <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">call</span>(context, accumulator, value, index, collection);
    };
  }
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">apply</span>(context, <span class="hljs-variable language_">arguments</span>);
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-106">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-106">&#182;</a>
              </div>
              <p>An internal function to generate callbacks that can be applied to each
element in a collection, returning the desired result — either <code>_.identity</code>,
an arbitrary callback, a property matcher, or a property accessor.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">baseIteratee</span>(<span class="hljs-params">value, context, argCount</span>) {
  <span class="hljs-keyword">if</span> (value == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> identity;
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isFunction$1</span>(value)) <span class="hljs-keyword">return</span> <span class="hljs-title function_">optimizeCb</span>(value, context, argCount);
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isObject</span>(value) &amp;&amp; !<span class="hljs-title function_">isArray</span>(value)) <span class="hljs-keyword">return</span> <span class="hljs-title function_">matcher</span>(value);
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">property</span>(value);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-107">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-107">&#182;</a>
              </div>
              <p>External wrapper for our callback generator. Users may customize
<code>_.iteratee</code> if they want additional predicate/iteratee shorthand styles.
This abstraction hides the internal-only <code>argCount</code> argument.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">iteratee</span>(<span class="hljs-params">value, context</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">baseIteratee</span>(value, context, <span class="hljs-title class_">Infinity</span>);
}
_$<span class="hljs-number">1.</span>iteratee = iteratee;</pre></div></div>
            
        </li>
        
        
        <li id="section-108">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-108">&#182;</a>
              </div>
              <p>The function we call internally to generate a callback. It invokes
<code>_.iteratee</code> if overridden, otherwise <code>baseIteratee</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">cb</span>(<span class="hljs-params">value, context, argCount</span>) {
  <span class="hljs-keyword">if</span> (_$<span class="hljs-number">1.</span>iteratee !== iteratee) <span class="hljs-keyword">return</span> _$<span class="hljs-number">1.</span><span class="hljs-title function_">iteratee</span>(value, context);
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">baseIteratee</span>(value, context, argCount);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-109">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-109">&#182;</a>
              </div>
              <p>Returns the results of applying the <code>iteratee</code> to each element of <code>obj</code>.
In contrast to <code>_.map</code> it returns an object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">mapObject</span>(<span class="hljs-params">obj, iteratee, context</span>) {
  iteratee = <span class="hljs-title function_">cb</span>(iteratee, context);
  <span class="hljs-keyword">var</span> _keys = <span class="hljs-title function_">keys</span>(obj),
      length = _keys.<span class="hljs-property">length</span>,
      results = {};
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
    <span class="hljs-keyword">var</span> currentKey = _keys[index];
    results[currentKey] = <span class="hljs-title function_">iteratee</span>(obj[currentKey], currentKey, obj);
  }
  <span class="hljs-keyword">return</span> results;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-110">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-110">&#182;</a>
              </div>
              <p>Predicate-generating function. Often useful outside of Underscore.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">noop</span>(<span class="hljs-params"></span>){}</pre></div></div>
            
        </li>
        
        
        <li id="section-111">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-111">&#182;</a>
              </div>
              <p>Generates a function for a given object that returns a given property.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">propertyOf</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> noop;
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">path</span>) {
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">get</span>(obj, path);
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-112">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-112">&#182;</a>
              </div>
              <p>Run a function <strong>n</strong> times.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">times</span>(<span class="hljs-params">n, iteratee, context</span>) {
  <span class="hljs-keyword">var</span> accum = <span class="hljs-title class_">Array</span>(<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(<span class="hljs-number">0</span>, n));
  iteratee = <span class="hljs-title function_">optimizeCb</span>(iteratee, context, <span class="hljs-number">1</span>);
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; n; i++) accum[i] = <span class="hljs-title function_">iteratee</span>(i);
  <span class="hljs-keyword">return</span> accum;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-113">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-113">&#182;</a>
              </div>
              <p>Return a random integer between <code>min</code> and <code>max</code> (inclusive).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">random</span>(<span class="hljs-params">min, max</span>) {
  <span class="hljs-keyword">if</span> (max == <span class="hljs-literal">null</span>) {
    max = min;
    min = <span class="hljs-number">0</span>;
  }
  <span class="hljs-keyword">return</span> min + <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">floor</span>(<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() * (max - min + <span class="hljs-number">1</span>));
}</pre></div></div>
            
        </li>
        
        
        <li id="section-114">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-114">&#182;</a>
              </div>
              <p>A (possibly faster) way to get the current timestamp as an integer.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> now = <span class="hljs-title class_">Date</span>.<span class="hljs-property">now</span> || <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>().<span class="hljs-title function_">getTime</span>();
};</pre></div></div>
            
        </li>
        
        
        <li id="section-115">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-115">&#182;</a>
              </div>
              <p>Internal helper to generate functions for escaping and unescaping strings
to/from HTML interpolation.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">createEscaper</span>(<span class="hljs-params">map</span>) {
  <span class="hljs-keyword">var</span> escaper = <span class="hljs-keyword">function</span>(<span class="hljs-params">match</span>) {
    <span class="hljs-keyword">return</span> map[match];
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-116">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-116">&#182;</a>
              </div>
              <p>Regexes for identifying a key that needs to be escaped.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> source = <span class="hljs-string">&#x27;(?:&#x27;</span> + <span class="hljs-title function_">keys</span>(map).<span class="hljs-title function_">join</span>(<span class="hljs-string">&#x27;|&#x27;</span>) + <span class="hljs-string">&#x27;)&#x27;</span>;
  <span class="hljs-keyword">var</span> testRegexp = <span class="hljs-title class_">RegExp</span>(source);
  <span class="hljs-keyword">var</span> replaceRegexp = <span class="hljs-title class_">RegExp</span>(source, <span class="hljs-string">&#x27;g&#x27;</span>);
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">string</span>) {
    string = string == <span class="hljs-literal">null</span> ? <span class="hljs-string">&#x27;&#x27;</span> : <span class="hljs-string">&#x27;&#x27;</span> + string;
    <span class="hljs-keyword">return</span> testRegexp.<span class="hljs-title function_">test</span>(string) ? string.<span class="hljs-title function_">replace</span>(replaceRegexp, escaper) : string;
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-117">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-117">&#182;</a>
              </div>
              <p>Internal list of HTML entities for escaping.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> escapeMap = {
  <span class="hljs-string">&#x27;&amp;&#x27;</span>: <span class="hljs-string">&#x27;&amp;amp;&#x27;</span>,
  <span class="hljs-string">&#x27;&lt;&#x27;</span>: <span class="hljs-string">&#x27;&amp;lt;&#x27;</span>,
  <span class="hljs-string">&#x27;&gt;&#x27;</span>: <span class="hljs-string">&#x27;&amp;gt;&#x27;</span>,
  <span class="hljs-string">&#x27;&quot;&#x27;</span>: <span class="hljs-string">&#x27;&amp;quot;&#x27;</span>,
  <span class="hljs-string">&quot;&#x27;&quot;</span>: <span class="hljs-string">&#x27;&amp;#x27;&#x27;</span>,
  <span class="hljs-string">&#x27;`&#x27;</span>: <span class="hljs-string">&#x27;&amp;#x60;&#x27;</span>
};</pre></div></div>
            
        </li>
        
        
        <li id="section-118">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-118">&#182;</a>
              </div>
              <p>Function for escaping strings to HTML interpolation.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> _escape = <span class="hljs-title function_">createEscaper</span>(escapeMap);</pre></div></div>
            
        </li>
        
        
        <li id="section-119">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-119">&#182;</a>
              </div>
              <p>Internal list of HTML entities for unescaping.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> unescapeMap = <span class="hljs-title function_">invert</span>(escapeMap);</pre></div></div>
            
        </li>
        
        
        <li id="section-120">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-120">&#182;</a>
              </div>
              <p>Function for unescaping strings from HTML interpolation.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> _unescape = <span class="hljs-title function_">createEscaper</span>(unescapeMap);</pre></div></div>
            
        </li>
        
        
        <li id="section-121">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-121">&#182;</a>
              </div>
              <p>By default, Underscore uses ERB-style template delimiters. Change the
following template settings to use alternative delimiters.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> templateSettings = _$<span class="hljs-number">1.</span>templateSettings = {
  <span class="hljs-attr">evaluate</span>: <span class="hljs-regexp">/&lt;%([\s\S]+?)%&gt;/g</span>,
  <span class="hljs-attr">interpolate</span>: <span class="hljs-regexp">/&lt;%=([\s\S]+?)%&gt;/g</span>,
  <span class="hljs-attr">escape</span>: <span class="hljs-regexp">/&lt;%-([\s\S]+?)%&gt;/g</span>
};</pre></div></div>
            
        </li>
        
        
        <li id="section-122">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-122">&#182;</a>
              </div>
              <p>When customizing <code>_.templateSettings</code>, if you don’t want to define an
interpolation, evaluation or escaping regex, we need one that is
guaranteed not to match.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> noMatch = <span class="hljs-regexp">/(.)^/</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-123">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-123">&#182;</a>
              </div>
              <p>Certain characters need to be escaped so that they can be put into a
string literal.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> escapes = {
  <span class="hljs-string">&quot;&#x27;&quot;</span>: <span class="hljs-string">&quot;&#x27;&quot;</span>,
  <span class="hljs-string">&#x27;\\&#x27;</span>: <span class="hljs-string">&#x27;\\&#x27;</span>,
  <span class="hljs-string">&#x27;\r&#x27;</span>: <span class="hljs-string">&#x27;r&#x27;</span>,
  <span class="hljs-string">&#x27;\n&#x27;</span>: <span class="hljs-string">&#x27;n&#x27;</span>,
  <span class="hljs-string">&#x27;\u2028&#x27;</span>: <span class="hljs-string">&#x27;u2028&#x27;</span>,
  <span class="hljs-string">&#x27;\u2029&#x27;</span>: <span class="hljs-string">&#x27;u2029&#x27;</span>
};

<span class="hljs-keyword">var</span> escapeRegExp = <span class="hljs-regexp">/\\|&#x27;|\r|\n|\u2028|\u2029/g</span>;

<span class="hljs-keyword">function</span> <span class="hljs-title function_">escapeChar</span>(<span class="hljs-params">match</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-string">&#x27;\\&#x27;</span> + escapes[match];
}</pre></div></div>
            
        </li>
        
        
        <li id="section-124">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-124">&#182;</a>
              </div>
              <p>In order to prevent third-party code injection through
<code>_.templateSettings.variable</code>, we test it against the following regular
expression. It is intentionally a bit more liberal than just matching valid
identifiers, but still prevents possible loopholes through defaults or
destructuring assignment.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> bareIdentifier = <span class="hljs-regexp">/^\s*(\w|\$)+\s*$/</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-125">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-125">&#182;</a>
              </div>
              <p>JavaScript micro-templating, similar to John Resig’s implementation.
Underscore templating handles arbitrary delimiters, preserves whitespace,
and correctly escapes quotes within interpolated code.
NB: <code>oldSettings</code> only exists for backwards compatibility.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">template</span>(<span class="hljs-params">text, settings, oldSettings</span>) {
  <span class="hljs-keyword">if</span> (!settings &amp;&amp; oldSettings) settings = oldSettings;
  settings = <span class="hljs-title function_">defaults</span>({}, settings, _$<span class="hljs-number">1.</span>templateSettings);</pre></div></div>
            
        </li>
        
        
        <li id="section-126">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-126">&#182;</a>
              </div>
              <p>Combine delimiters into one regular expression via alternation.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> matcher = <span class="hljs-title class_">RegExp</span>([
    (settings.<span class="hljs-property">escape</span> || noMatch).<span class="hljs-property">source</span>,
    (settings.<span class="hljs-property">interpolate</span> || noMatch).<span class="hljs-property">source</span>,
    (settings.<span class="hljs-property">evaluate</span> || noMatch).<span class="hljs-property">source</span>
  ].<span class="hljs-title function_">join</span>(<span class="hljs-string">&#x27;|&#x27;</span>) + <span class="hljs-string">&#x27;|$&#x27;</span>, <span class="hljs-string">&#x27;g&#x27;</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-127">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-127">&#182;</a>
              </div>
              <p>Compile the template source, escaping string literals appropriately.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>;
  <span class="hljs-keyword">var</span> source = <span class="hljs-string">&quot;__p+=&#x27;&quot;</span>;
  text.<span class="hljs-title function_">replace</span>(matcher, <span class="hljs-keyword">function</span>(<span class="hljs-params">match, <span class="hljs-built_in">escape</span>, interpolate, evaluate, offset</span>) {
    source += text.<span class="hljs-title function_">slice</span>(index, offset).<span class="hljs-title function_">replace</span>(escapeRegExp, escapeChar);
    index = offset + match.<span class="hljs-property">length</span>;

    <span class="hljs-keyword">if</span> (<span class="hljs-built_in">escape</span>) {
      source += <span class="hljs-string">&quot;&#x27;+\n((__t=(&quot;</span> + <span class="hljs-built_in">escape</span> + <span class="hljs-string">&quot;))==null?&#x27;&#x27;:_.escape(__t))+\n&#x27;&quot;</span>;
    } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (interpolate) {
      source += <span class="hljs-string">&quot;&#x27;+\n((__t=(&quot;</span> + interpolate + <span class="hljs-string">&quot;))==null?&#x27;&#x27;:__t)+\n&#x27;&quot;</span>;
    } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (evaluate) {
      source += <span class="hljs-string">&quot;&#x27;;\n&quot;</span> + evaluate + <span class="hljs-string">&quot;\n__p+=&#x27;&quot;</span>;
    }</pre></div></div>
            
        </li>
        
        
        <li id="section-128">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-128">&#182;</a>
              </div>
              <p>Adobe VMs need the match returned to produce the correct offset.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">return</span> match;
  });
  source += <span class="hljs-string">&quot;&#x27;;\n&quot;</span>;

  <span class="hljs-keyword">var</span> argument = settings.<span class="hljs-property">variable</span>;
  <span class="hljs-keyword">if</span> (argument) {</pre></div></div>
            
        </li>
        
        
        <li id="section-129">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-129">&#182;</a>
              </div>
              <p>Insure against third-party code injection. (CVE-2021-23358)</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (!bareIdentifier.<span class="hljs-title function_">test</span>(argument)) <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(
      <span class="hljs-string">&#x27;variable is not a bare identifier: &#x27;</span> + argument
    );
  } <span class="hljs-keyword">else</span> {</pre></div></div>
            
        </li>
        
        
        <li id="section-130">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-130">&#182;</a>
              </div>
              <p>If a variable is not specified, place data values in local scope.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    source = <span class="hljs-string">&#x27;with(obj||{}){\n&#x27;</span> + source + <span class="hljs-string">&#x27;}\n&#x27;</span>;
    argument = <span class="hljs-string">&#x27;obj&#x27;</span>;
  }

  source = <span class="hljs-string">&quot;var __t,__p=&#x27;&#x27;,__j=Array.prototype.join,&quot;</span> +
    <span class="hljs-string">&quot;print=function(){__p+=__j.call(arguments,&#x27;&#x27;);};\n&quot;</span> +
    source + <span class="hljs-string">&#x27;return __p;\n&#x27;</span>;

  <span class="hljs-keyword">var</span> render;
  <span class="hljs-keyword">try</span> {
    render = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Function</span>(argument, <span class="hljs-string">&#x27;_&#x27;</span>, source);
  } <span class="hljs-keyword">catch</span> (e) {
    e.<span class="hljs-property">source</span> = source;
    <span class="hljs-keyword">throw</span> e;
  }

  <span class="hljs-keyword">var</span> template = <span class="hljs-keyword">function</span>(<span class="hljs-params">data</span>) {
    <span class="hljs-keyword">return</span> render.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, data, _$<span class="hljs-number">1</span>);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-131">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-131">&#182;</a>
              </div>
              <p>Provide the compiled source as a convenience for precompilation.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  template.<span class="hljs-property">source</span> = <span class="hljs-string">&#x27;function(&#x27;</span> + argument + <span class="hljs-string">&#x27;){\n&#x27;</span> + source + <span class="hljs-string">&#x27;}&#x27;</span>;

  <span class="hljs-keyword">return</span> template;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-132">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-132">&#182;</a>
              </div>
              <p>Traverses the children of <code>obj</code> along <code>path</code>. If a child is a function, it
is invoked with its parent as context. Returns the value of the final
child, or <code>fallback</code> if any child is undefined.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">result</span>(<span class="hljs-params">obj, path, fallback</span>) {
  path = <span class="hljs-title function_">toPath</span>(path);
  <span class="hljs-keyword">var</span> length = path.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">if</span> (!length) {
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">isFunction$1</span>(fallback) ? fallback.<span class="hljs-title function_">call</span>(obj) : fallback;
  }
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
    <span class="hljs-keyword">var</span> prop = obj == <span class="hljs-literal">null</span> ? <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> : obj[path[i]];
    <span class="hljs-keyword">if</span> (prop === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) {
      prop = fallback;
      i = length; <span class="hljs-comment">// Ensure we don&#x27;t continue iterating.</span>
    }
    obj = <span class="hljs-title function_">isFunction$1</span>(prop) ? prop.<span class="hljs-title function_">call</span>(obj) : prop;
  }
  <span class="hljs-keyword">return</span> obj;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-133">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-133">&#182;</a>
              </div>
              <p>Generate a unique integer id (unique within the entire client session).
Useful for temporary DOM ids.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> idCounter = <span class="hljs-number">0</span>;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">uniqueId</span>(<span class="hljs-params">prefix</span>) {
  <span class="hljs-keyword">var</span> id = ++idCounter + <span class="hljs-string">&#x27;&#x27;</span>;
  <span class="hljs-keyword">return</span> prefix ? prefix + id : id;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-134">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-134">&#182;</a>
              </div>
              <p>Start chaining a wrapped Underscore object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">chain</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">var</span> instance = <span class="hljs-title function_">_$1</span>(obj);
  instance.<span class="hljs-property">_chain</span> = <span class="hljs-literal">true</span>;
  <span class="hljs-keyword">return</span> instance;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-135">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-135">&#182;</a>
              </div>
              <p>Internal function to execute <code>sourceFunc</code> bound to <code>context</code> with optional
<code>args</code>. Determines whether to execute a function as a constructor or as a
normal function.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">executeBound</span>(<span class="hljs-params">sourceFunc, boundFunc, context, callingContext, args</span>) {
  <span class="hljs-keyword">if</span> (!(callingContext <span class="hljs-keyword">instanceof</span> boundFunc)) <span class="hljs-keyword">return</span> sourceFunc.<span class="hljs-title function_">apply</span>(context, args);
  <span class="hljs-keyword">var</span> self = <span class="hljs-title function_">baseCreate</span>(sourceFunc.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>);
  <span class="hljs-keyword">var</span> result = sourceFunc.<span class="hljs-title function_">apply</span>(self, args);
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isObject</span>(result)) <span class="hljs-keyword">return</span> result;
  <span class="hljs-keyword">return</span> self;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-136">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-136">&#182;</a>
              </div>
              <p>Partially apply a function by creating a version that has had some of its
arguments pre-filled, without changing its dynamic <code>this</code> context. <code>_</code> acts
as a placeholder by default, allowing any combination of arguments to be
pre-filled. Set <code>_.partial.placeholder</code> for a custom placeholder argument.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> partial = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">func, boundArgs</span>) {
  <span class="hljs-keyword">var</span> placeholder = partial.<span class="hljs-property">placeholder</span>;
  <span class="hljs-keyword">var</span> bound = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">var</span> position = <span class="hljs-number">0</span>, length = boundArgs.<span class="hljs-property">length</span>;
    <span class="hljs-keyword">var</span> args = <span class="hljs-title class_">Array</span>(length);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
      args[i] = boundArgs[i] === placeholder ? <span class="hljs-variable language_">arguments</span>[position++] : boundArgs[i];
    }
    <span class="hljs-keyword">while</span> (position &lt; <span class="hljs-variable language_">arguments</span>.<span class="hljs-property">length</span>) args.<span class="hljs-title function_">push</span>(<span class="hljs-variable language_">arguments</span>[position++]);
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">executeBound</span>(func, bound, <span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">this</span>, args);
  };
  <span class="hljs-keyword">return</span> bound;
});

partial.<span class="hljs-property">placeholder</span> = _$<span class="hljs-number">1</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-137">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-137">&#182;</a>
              </div>
              <p>Create a function bound to a given object (assigning <code>this</code>, and arguments,
optionally).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> bind = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">func, context, args</span>) {
  <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isFunction$1</span>(func)) <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">&#x27;Bind must be called on a function&#x27;</span>);
  <span class="hljs-keyword">var</span> bound = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">callArgs</span>) {
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">executeBound</span>(func, bound, context, <span class="hljs-variable language_">this</span>, args.<span class="hljs-title function_">concat</span>(callArgs));
  });
  <span class="hljs-keyword">return</span> bound;
});</pre></div></div>
            
        </li>
        
        
        <li id="section-138">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-138">&#182;</a>
              </div>
              <p>Internal helper for collection methods to determine whether a collection
should be iterated as an array or as an object.
Related: <a href="https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength">https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength</a>
Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> isArrayLike = <span class="hljs-title function_">createSizePropertyCheck</span>(getLength);</pre></div></div>
            
        </li>
        
        
        <li id="section-139">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-139">&#182;</a>
              </div>
              <p>Internal implementation of a recursive <code>flatten</code> function.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">flatten$1</span>(<span class="hljs-params">input, depth, strict, output</span>) {
  output = output || [];
  <span class="hljs-keyword">if</span> (!depth &amp;&amp; depth !== <span class="hljs-number">0</span>) {
    depth = <span class="hljs-title class_">Infinity</span>;
  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (depth &lt;= <span class="hljs-number">0</span>) {
    <span class="hljs-keyword">return</span> output.<span class="hljs-title function_">concat</span>(input);
  }
  <span class="hljs-keyword">var</span> idx = output.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = <span class="hljs-title function_">getLength</span>(input); i &lt; length; i++) {
    <span class="hljs-keyword">var</span> value = input[i];
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isArrayLike</span>(value) &amp;&amp; (<span class="hljs-title function_">isArray</span>(value) || <span class="hljs-title function_">isArguments$1</span>(value))) {</pre></div></div>
            
        </li>
        
        
        <li id="section-140">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-140">&#182;</a>
              </div>
              <p>Flatten current level of array or arguments object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">if</span> (depth &gt; <span class="hljs-number">1</span>) {
        <span class="hljs-title function_">flatten$1</span>(value, depth - <span class="hljs-number">1</span>, strict, output);
        idx = output.<span class="hljs-property">length</span>;
      } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">var</span> j = <span class="hljs-number">0</span>, len = value.<span class="hljs-property">length</span>;
        <span class="hljs-keyword">while</span> (j &lt; len) output[idx++] = value[j++];
      }
    } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!strict) {
      output[idx++] = value;
    }
  }
  <span class="hljs-keyword">return</span> output;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-141">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-141">&#182;</a>
              </div>
              <p>Bind a number of an object’s methods to that object. Remaining arguments
are the method names to be bound. Useful for ensuring that all callbacks
defined on an object belong to it.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> bindAll = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">obj, keys</span>) {
  keys = <span class="hljs-title function_">flatten$1</span>(keys, <span class="hljs-literal">false</span>, <span class="hljs-literal">false</span>);
  <span class="hljs-keyword">var</span> index = keys.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">if</span> (index &lt; <span class="hljs-number">1</span>) <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">&#x27;bindAll must be passed function names&#x27;</span>);
  <span class="hljs-keyword">while</span> (index--) {
    <span class="hljs-keyword">var</span> key = keys[index];
    obj[key] = <span class="hljs-title function_">bind</span>(obj[key], obj);
  }
  <span class="hljs-keyword">return</span> obj;
});</pre></div></div>
            
        </li>
        
        
        <li id="section-142">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-142">&#182;</a>
              </div>
              <p>Memoize an expensive function by storing its results.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">memoize</span>(<span class="hljs-params">func, hasher</span>) {
  <span class="hljs-keyword">var</span> memoize = <span class="hljs-keyword">function</span>(<span class="hljs-params">key</span>) {
    <span class="hljs-keyword">var</span> cache = memoize.<span class="hljs-property">cache</span>;
    <span class="hljs-keyword">var</span> address = <span class="hljs-string">&#x27;&#x27;</span> + (hasher ? hasher.<span class="hljs-title function_">apply</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">arguments</span>) : key);
    <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">has$1</span>(cache, address)) cache[address] = func.<span class="hljs-title function_">apply</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">arguments</span>);
    <span class="hljs-keyword">return</span> cache[address];
  };
  memoize.<span class="hljs-property">cache</span> = {};
  <span class="hljs-keyword">return</span> memoize;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-143">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-143">&#182;</a>
              </div>
              <p>Delays a function for the given number of milliseconds, and then calls
it with the arguments supplied.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> delay = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">func, wait, args</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-built_in">setTimeout</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">apply</span>(<span class="hljs-literal">null</span>, args);
  }, wait);
});</pre></div></div>
            
        </li>
        
        
        <li id="section-144">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-144">&#182;</a>
              </div>
              <p>Defers a function, scheduling it to run after the current call stack has
cleared.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> defer = <span class="hljs-title function_">partial</span>(delay, _$<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-145">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-145">&#182;</a>
              </div>
              <p>Returns a function, that, when invoked, will only be triggered at most once
during a given window of time. Normally, the throttled function will run
as much as it can, without ever going more than once per <code>wait</code> duration;
but if you’d like to disable the execution on the leading edge, pass
<code>{leading: false}</code>. To disable execution on the trailing edge, ditto.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">throttle</span>(<span class="hljs-params">func, wait, options</span>) {
  <span class="hljs-keyword">var</span> timeout, context, args, result;
  <span class="hljs-keyword">var</span> previous = <span class="hljs-number">0</span>;
  <span class="hljs-keyword">if</span> (!options) options = {};

  <span class="hljs-keyword">var</span> later = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    previous = options.<span class="hljs-property">leading</span> === <span class="hljs-literal">false</span> ? <span class="hljs-number">0</span> : <span class="hljs-title function_">now</span>();
    timeout = <span class="hljs-literal">null</span>;
    result = func.<span class="hljs-title function_">apply</span>(context, args);
    <span class="hljs-keyword">if</span> (!timeout) context = args = <span class="hljs-literal">null</span>;
  };

  <span class="hljs-keyword">var</span> throttled = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">var</span> _now = <span class="hljs-title function_">now</span>();
    <span class="hljs-keyword">if</span> (!previous &amp;&amp; options.<span class="hljs-property">leading</span> === <span class="hljs-literal">false</span>) previous = _now;
    <span class="hljs-keyword">var</span> remaining = wait - (_now - previous);
    context = <span class="hljs-variable language_">this</span>;
    args = <span class="hljs-variable language_">arguments</span>;
    <span class="hljs-keyword">if</span> (remaining &lt;= <span class="hljs-number">0</span> || remaining &gt; wait) {
      <span class="hljs-keyword">if</span> (timeout) {
        <span class="hljs-built_in">clearTimeout</span>(timeout);
        timeout = <span class="hljs-literal">null</span>;
      }
      previous = _now;
      result = func.<span class="hljs-title function_">apply</span>(context, args);
      <span class="hljs-keyword">if</span> (!timeout) context = args = <span class="hljs-literal">null</span>;
    } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!timeout &amp;&amp; options.<span class="hljs-property">trailing</span> !== <span class="hljs-literal">false</span>) {
      timeout = <span class="hljs-built_in">setTimeout</span>(later, remaining);
    }
    <span class="hljs-keyword">return</span> result;
  };

  throttled.<span class="hljs-property">cancel</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-built_in">clearTimeout</span>(timeout);
    previous = <span class="hljs-number">0</span>;
    timeout = context = args = <span class="hljs-literal">null</span>;
  };

  <span class="hljs-keyword">return</span> throttled;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-146">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-146">&#182;</a>
              </div>
              <p>When a sequence of calls of the returned function ends, the argument
function is triggered. The end of a sequence is defined by the <code>wait</code>
parameter. If <code>immediate</code> is passed, the argument function will be
triggered at the beginning of the sequence instead of at the end.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">debounce</span>(<span class="hljs-params">func, wait, immediate</span>) {
  <span class="hljs-keyword">var</span> timeout, previous, args, result, context;

  <span class="hljs-keyword">var</span> later = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">var</span> passed = <span class="hljs-title function_">now</span>() - previous;
    <span class="hljs-keyword">if</span> (wait &gt; passed) {
      timeout = <span class="hljs-built_in">setTimeout</span>(later, wait - passed);
    } <span class="hljs-keyword">else</span> {
      timeout = <span class="hljs-literal">null</span>;
      <span class="hljs-keyword">if</span> (!immediate) result = func.<span class="hljs-title function_">apply</span>(context, args);</pre></div></div>
            
        </li>
        
        
        <li id="section-147">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-147">&#182;</a>
              </div>
              <p>This check is needed because <code>func</code> can recursively invoke <code>debounced</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">if</span> (!timeout) args = context = <span class="hljs-literal">null</span>;
    }
  };

  <span class="hljs-keyword">var</span> debounced = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">_args</span>) {
    context = <span class="hljs-variable language_">this</span>;
    args = _args;
    previous = <span class="hljs-title function_">now</span>();
    <span class="hljs-keyword">if</span> (!timeout) {
      timeout = <span class="hljs-built_in">setTimeout</span>(later, wait);
      <span class="hljs-keyword">if</span> (immediate) result = func.<span class="hljs-title function_">apply</span>(context, args);
    }
    <span class="hljs-keyword">return</span> result;
  });

  debounced.<span class="hljs-property">cancel</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-built_in">clearTimeout</span>(timeout);
    timeout = args = context = <span class="hljs-literal">null</span>;
  };

  <span class="hljs-keyword">return</span> debounced;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-148">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-148">&#182;</a>
              </div>
              <p>Returns the first function passed as an argument to the second,
allowing you to adjust arguments, run code before and after, and
conditionally execute the original function.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">wrap</span>(<span class="hljs-params">func, wrapper</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">partial</span>(wrapper, func);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-149">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-149">&#182;</a>
              </div>
              <p>Returns a negated version of the passed-in predicate.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">negate</span>(<span class="hljs-params">predicate</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">return</span> !predicate.<span class="hljs-title function_">apply</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">arguments</span>);
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-150">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-150">&#182;</a>
              </div>
              <p>Returns a function that is the composition of a list of functions, each
consuming the return value of the function that follows.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">compose</span>(<span class="hljs-params"></span>) {
  <span class="hljs-keyword">var</span> args = <span class="hljs-variable language_">arguments</span>;
  <span class="hljs-keyword">var</span> start = args.<span class="hljs-property">length</span> - <span class="hljs-number">1</span>;
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">var</span> i = start;
    <span class="hljs-keyword">var</span> result = args[start].<span class="hljs-title function_">apply</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">arguments</span>);
    <span class="hljs-keyword">while</span> (i--) result = args[i].<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, result);
    <span class="hljs-keyword">return</span> result;
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-151">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-151">&#182;</a>
              </div>
              <p>Returns a function that will only be executed on and after the Nth call.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">after</span>(<span class="hljs-params">times, func</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">if</span> (--times &lt; <span class="hljs-number">1</span>) {
      <span class="hljs-keyword">return</span> func.<span class="hljs-title function_">apply</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">arguments</span>);
    }
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-152">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-152">&#182;</a>
              </div>
              <p>Returns a function that will only be executed up to (but not including) the
Nth call.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">before</span>(<span class="hljs-params">times, func</span>) {
  <span class="hljs-keyword">var</span> memo;
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">if</span> (--times &gt; <span class="hljs-number">0</span>) {
      memo = func.<span class="hljs-title function_">apply</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">arguments</span>);
    }
    <span class="hljs-keyword">if</span> (times &lt;= <span class="hljs-number">1</span>) func = <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">return</span> memo;
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-153">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-153">&#182;</a>
              </div>
              <p>Returns a function that will be executed at most one time, no matter how
often you call it. Useful for lazy initialization.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> once = <span class="hljs-title function_">partial</span>(before, <span class="hljs-number">2</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-154">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-154">&#182;</a>
              </div>
              <p>Returns the first key on an object that passes a truth test.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">findKey</span>(<span class="hljs-params">obj, predicate, context</span>) {
  predicate = <span class="hljs-title function_">cb</span>(predicate, context);
  <span class="hljs-keyword">var</span> _keys = <span class="hljs-title function_">keys</span>(obj), key;
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = _keys.<span class="hljs-property">length</span>; i &lt; length; i++) {
    key = _keys[i];
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">predicate</span>(obj[key], key, obj)) <span class="hljs-keyword">return</span> key;
  }
}</pre></div></div>
            
        </li>
        
        
        <li id="section-155">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-155">&#182;</a>
              </div>
              <p>Internal function to generate <code>_.findIndex</code> and <code>_.findLastIndex</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">createPredicateIndexFinder</span>(<span class="hljs-params">dir</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">array, predicate, context</span>) {
    predicate = <span class="hljs-title function_">cb</span>(predicate, context);
    <span class="hljs-keyword">var</span> length = <span class="hljs-title function_">getLength</span>(array);
    <span class="hljs-keyword">var</span> index = dir &gt; <span class="hljs-number">0</span> ? <span class="hljs-number">0</span> : length - <span class="hljs-number">1</span>;
    <span class="hljs-keyword">for</span> (; index &gt;= <span class="hljs-number">0</span> &amp;&amp; index &lt; length; index += dir) {
      <span class="hljs-keyword">if</span> (<span class="hljs-title function_">predicate</span>(array[index], index, array)) <span class="hljs-keyword">return</span> index;
    }
    <span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>;
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-156">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-156">&#182;</a>
              </div>
              <p>Returns the first index on an array-like that passes a truth test.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> findIndex = <span class="hljs-title function_">createPredicateIndexFinder</span>(<span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-157">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-157">&#182;</a>
              </div>
              <p>Returns the last index on an array-like that passes a truth test.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> findLastIndex = <span class="hljs-title function_">createPredicateIndexFinder</span>(-<span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-158">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-158">&#182;</a>
              </div>
              <p>Use a comparator function to figure out the smallest index at which
an object should be inserted so as to maintain order. Uses binary search.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">sortedIndex</span>(<span class="hljs-params">array, obj, iteratee, context</span>) {
  iteratee = <span class="hljs-title function_">cb</span>(iteratee, context, <span class="hljs-number">1</span>);
  <span class="hljs-keyword">var</span> value = <span class="hljs-title function_">iteratee</span>(obj);
  <span class="hljs-keyword">var</span> low = <span class="hljs-number">0</span>, high = <span class="hljs-title function_">getLength</span>(array);
  <span class="hljs-keyword">while</span> (low &lt; high) {
    <span class="hljs-keyword">var</span> mid = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">floor</span>((low + high) / <span class="hljs-number">2</span>);
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">iteratee</span>(array[mid]) &lt; value) low = mid + <span class="hljs-number">1</span>; <span class="hljs-keyword">else</span> high = mid;
  }
  <span class="hljs-keyword">return</span> low;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-159">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-159">&#182;</a>
              </div>
              <p>Internal function to generate the <code>_.indexOf</code> and <code>_.lastIndexOf</code> functions.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">createIndexFinder</span>(<span class="hljs-params">dir, predicateFind, sortedIndex</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">array, item, idx</span>) {
    <span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = <span class="hljs-title function_">getLength</span>(array);
    <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> idx == <span class="hljs-string">&#x27;number&#x27;</span>) {
      <span class="hljs-keyword">if</span> (dir &gt; <span class="hljs-number">0</span>) {
        i = idx &gt;= <span class="hljs-number">0</span> ? idx : <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(idx + length, i);
      } <span class="hljs-keyword">else</span> {
        length = idx &gt;= <span class="hljs-number">0</span> ? <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">min</span>(idx + <span class="hljs-number">1</span>, length) : idx + length + <span class="hljs-number">1</span>;
      }
    } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (sortedIndex &amp;&amp; idx &amp;&amp; length) {
      idx = <span class="hljs-title function_">sortedIndex</span>(array, item);
      <span class="hljs-keyword">return</span> array[idx] === item ? idx : -<span class="hljs-number">1</span>;
    }
    <span class="hljs-keyword">if</span> (item !== item) {
      idx = <span class="hljs-title function_">predicateFind</span>(slice.<span class="hljs-title function_">call</span>(array, i, length), isNaN$<span class="hljs-number">1</span>);
      <span class="hljs-keyword">return</span> idx &gt;= <span class="hljs-number">0</span> ? idx + i : -<span class="hljs-number">1</span>;
    }
    <span class="hljs-keyword">for</span> (idx = dir &gt; <span class="hljs-number">0</span> ? i : length - <span class="hljs-number">1</span>; idx &gt;= <span class="hljs-number">0</span> &amp;&amp; idx &lt; length; idx += dir) {
      <span class="hljs-keyword">if</span> (array[idx] === item) <span class="hljs-keyword">return</span> idx;
    }
    <span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>;
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-160">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-160">&#182;</a>
              </div>
              <p>Return the position of the first occurrence of an item in an array,
or -1 if the item is not included in the array.
If the array is large and already in sort order, pass <code>true</code>
for <strong>isSorted</strong> to use binary search.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> indexOf = <span class="hljs-title function_">createIndexFinder</span>(<span class="hljs-number">1</span>, findIndex, sortedIndex);</pre></div></div>
            
        </li>
        
        
        <li id="section-161">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-161">&#182;</a>
              </div>
              <p>Return the position of the last occurrence of an item in an array,
or -1 if the item is not included in the array.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> lastIndexOf = <span class="hljs-title function_">createIndexFinder</span>(-<span class="hljs-number">1</span>, findLastIndex);</pre></div></div>
            
        </li>
        
        
        <li id="section-162">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-162">&#182;</a>
              </div>
              <p>Return the first value which passes a truth test.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">find</span>(<span class="hljs-params">obj, predicate, context</span>) {
  <span class="hljs-keyword">var</span> keyFinder = <span class="hljs-title function_">isArrayLike</span>(obj) ? findIndex : findKey;
  <span class="hljs-keyword">var</span> key = <span class="hljs-title function_">keyFinder</span>(obj, predicate, context);
  <span class="hljs-keyword">if</span> (key !== <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> &amp;&amp; key !== -<span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> obj[key];
}</pre></div></div>
            
        </li>
        
        
        <li id="section-163">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-163">&#182;</a>
              </div>
              <p>Convenience version of a common use case of <code>_.find</code>: getting the first
object containing specific <code>key:value</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">findWhere</span>(<span class="hljs-params">obj, attrs</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">find</span>(obj, <span class="hljs-title function_">matcher</span>(attrs));
}</pre></div></div>
            
        </li>
        
        
        <li id="section-164">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-164">&#182;</a>
              </div>
              <p>The cornerstone for collection functions, an <code>each</code>
implementation, aka <code>forEach</code>.
Handles raw objects in addition to array-likes. Treats all
sparse array-likes as if they were dense.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">each</span>(<span class="hljs-params">obj, iteratee, context</span>) {
  iteratee = <span class="hljs-title function_">optimizeCb</span>(iteratee, context);
  <span class="hljs-keyword">var</span> i, length;
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isArrayLike</span>(obj)) {
    <span class="hljs-keyword">for</span> (i = <span class="hljs-number">0</span>, length = obj.<span class="hljs-property">length</span>; i &lt; length; i++) {
      <span class="hljs-title function_">iteratee</span>(obj[i], i, obj);
    }
  } <span class="hljs-keyword">else</span> {
    <span class="hljs-keyword">var</span> _keys = <span class="hljs-title function_">keys</span>(obj);
    <span class="hljs-keyword">for</span> (i = <span class="hljs-number">0</span>, length = _keys.<span class="hljs-property">length</span>; i &lt; length; i++) {
      <span class="hljs-title function_">iteratee</span>(obj[_keys[i]], _keys[i], obj);
    }
  }
  <span class="hljs-keyword">return</span> obj;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-165">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-165">&#182;</a>
              </div>
              <p>Return the results of applying the iteratee to each element.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">map</span>(<span class="hljs-params">obj, iteratee, context</span>) {
  iteratee = <span class="hljs-title function_">cb</span>(iteratee, context);
  <span class="hljs-keyword">var</span> _keys = !<span class="hljs-title function_">isArrayLike</span>(obj) &amp;&amp; <span class="hljs-title function_">keys</span>(obj),
      length = (_keys || obj).<span class="hljs-property">length</span>,
      results = <span class="hljs-title class_">Array</span>(length);
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
    <span class="hljs-keyword">var</span> currentKey = _keys ? _keys[index] : index;
    results[index] = <span class="hljs-title function_">iteratee</span>(obj[currentKey], currentKey, obj);
  }
  <span class="hljs-keyword">return</span> results;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-166">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-166">&#182;</a>
              </div>
              <p>Internal helper to create a reducing function, iterating left or right.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">createReduce</span>(<span class="hljs-params">dir</span>) {</pre></div></div>
            
        </li>
        
        
        <li id="section-167">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-167">&#182;</a>
              </div>
              <p>Wrap code that reassigns argument variables in a separate function than
the one that accesses <code>arguments.length</code> to avoid a perf hit. (#1991)</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> reducer = <span class="hljs-keyword">function</span>(<span class="hljs-params">obj, iteratee, memo, initial</span>) {
    <span class="hljs-keyword">var</span> _keys = !<span class="hljs-title function_">isArrayLike</span>(obj) &amp;&amp; <span class="hljs-title function_">keys</span>(obj),
        length = (_keys || obj).<span class="hljs-property">length</span>,
        index = dir &gt; <span class="hljs-number">0</span> ? <span class="hljs-number">0</span> : length - <span class="hljs-number">1</span>;
    <span class="hljs-keyword">if</span> (!initial) {
      memo = obj[_keys ? _keys[index] : index];
      index += dir;
    }
    <span class="hljs-keyword">for</span> (; index &gt;= <span class="hljs-number">0</span> &amp;&amp; index &lt; length; index += dir) {
      <span class="hljs-keyword">var</span> currentKey = _keys ? _keys[index] : index;
      memo = <span class="hljs-title function_">iteratee</span>(memo, obj[currentKey], currentKey, obj);
    }
    <span class="hljs-keyword">return</span> memo;
  };

  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">obj, iteratee, memo, context</span>) {
    <span class="hljs-keyword">var</span> initial = <span class="hljs-variable language_">arguments</span>.<span class="hljs-property">length</span> &gt;= <span class="hljs-number">3</span>;
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">reducer</span>(obj, <span class="hljs-title function_">optimizeCb</span>(iteratee, context, <span class="hljs-number">4</span>), memo, initial);
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-168">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-168">&#182;</a>
              </div>
              <p><strong>Reduce</strong> builds up a single result from a list of values, aka <code>inject</code>,
or <code>foldl</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> reduce = <span class="hljs-title function_">createReduce</span>(<span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-169">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-169">&#182;</a>
              </div>
              <p>The right-associative version of reduce, also known as <code>foldr</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> reduceRight = <span class="hljs-title function_">createReduce</span>(-<span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-170">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-170">&#182;</a>
              </div>
              <p>Return all the elements that pass a truth test.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">filter</span>(<span class="hljs-params">obj, predicate, context</span>) {
  <span class="hljs-keyword">var</span> results = [];
  predicate = <span class="hljs-title function_">cb</span>(predicate, context);
  <span class="hljs-title function_">each</span>(obj, <span class="hljs-keyword">function</span>(<span class="hljs-params">value, index, list</span>) {
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">predicate</span>(value, index, list)) results.<span class="hljs-title function_">push</span>(value);
  });
  <span class="hljs-keyword">return</span> results;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-171">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-171">&#182;</a>
              </div>
              <p>Return all the elements for which a truth test fails.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">reject</span>(<span class="hljs-params">obj, predicate, context</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">filter</span>(obj, <span class="hljs-title function_">negate</span>(<span class="hljs-title function_">cb</span>(predicate)), context);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-172">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-172">&#182;</a>
              </div>
              <p>Determine whether all of the elements pass a truth test.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">every</span>(<span class="hljs-params">obj, predicate, context</span>) {
  predicate = <span class="hljs-title function_">cb</span>(predicate, context);
  <span class="hljs-keyword">var</span> _keys = !<span class="hljs-title function_">isArrayLike</span>(obj) &amp;&amp; <span class="hljs-title function_">keys</span>(obj),
      length = (_keys || obj).<span class="hljs-property">length</span>;
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
    <span class="hljs-keyword">var</span> currentKey = _keys ? _keys[index] : index;
    <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">predicate</span>(obj[currentKey], currentKey, obj)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
  }
  <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-173">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-173">&#182;</a>
              </div>
              <p>Determine if at least one element in the object passes a truth test.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">some</span>(<span class="hljs-params">obj, predicate, context</span>) {
  predicate = <span class="hljs-title function_">cb</span>(predicate, context);
  <span class="hljs-keyword">var</span> _keys = !<span class="hljs-title function_">isArrayLike</span>(obj) &amp;&amp; <span class="hljs-title function_">keys</span>(obj),
      length = (_keys || obj).<span class="hljs-property">length</span>;
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
    <span class="hljs-keyword">var</span> currentKey = _keys ? _keys[index] : index;
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">predicate</span>(obj[currentKey], currentKey, obj)) <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
  }
  <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-174">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-174">&#182;</a>
              </div>
              <p>Determine if the array or object contains a given item (using <code>===</code>).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">contains</span>(<span class="hljs-params">obj, item, fromIndex, guard</span>) {
  <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isArrayLike</span>(obj)) obj = <span class="hljs-title function_">values</span>(obj);
  <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> fromIndex != <span class="hljs-string">&#x27;number&#x27;</span> || guard) fromIndex = <span class="hljs-number">0</span>;
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">indexOf</span>(obj, item, fromIndex) &gt;= <span class="hljs-number">0</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-175">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-175">&#182;</a>
              </div>
              <p>Invoke a method (with arguments) on every item in a collection.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> invoke = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">obj, path, args</span>) {
  <span class="hljs-keyword">var</span> contextPath, func;
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isFunction$1</span>(path)) {
    func = path;
  } <span class="hljs-keyword">else</span> {
    path = <span class="hljs-title function_">toPath</span>(path);
    contextPath = path.<span class="hljs-title function_">slice</span>(<span class="hljs-number">0</span>, -<span class="hljs-number">1</span>);
    path = path[path.<span class="hljs-property">length</span> - <span class="hljs-number">1</span>];
  }
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">map</span>(obj, <span class="hljs-keyword">function</span>(<span class="hljs-params">context</span>) {
    <span class="hljs-keyword">var</span> method = func;
    <span class="hljs-keyword">if</span> (!method) {
      <span class="hljs-keyword">if</span> (contextPath &amp;&amp; contextPath.<span class="hljs-property">length</span>) {
        context = <span class="hljs-title function_">deepGet</span>(context, contextPath);
      }
      <span class="hljs-keyword">if</span> (context == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>;
      method = context[path];
    }
    <span class="hljs-keyword">return</span> method == <span class="hljs-literal">null</span> ? method : method.<span class="hljs-title function_">apply</span>(context, args);
  });
});</pre></div></div>
            
        </li>
        
        
        <li id="section-176">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-176">&#182;</a>
              </div>
              <p>Convenience version of a common use case of <code>_.map</code>: fetching a property.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">pluck</span>(<span class="hljs-params">obj, key</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">map</span>(obj, <span class="hljs-title function_">property</span>(key));
}</pre></div></div>
            
        </li>
        
        
        <li id="section-177">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-177">&#182;</a>
              </div>
              <p>Convenience version of a common use case of <code>_.filter</code>: selecting only
objects containing specific <code>key:value</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">where</span>(<span class="hljs-params">obj, attrs</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">filter</span>(obj, <span class="hljs-title function_">matcher</span>(attrs));
}</pre></div></div>
            
        </li>
        
        
        <li id="section-178">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-178">&#182;</a>
              </div>
              <p>Return the maximum element (or element-based computation).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">max</span>(<span class="hljs-params">obj, iteratee, context</span>) {
  <span class="hljs-keyword">var</span> result = -<span class="hljs-title class_">Infinity</span>, lastComputed = -<span class="hljs-title class_">Infinity</span>,
      value, computed;
  <span class="hljs-keyword">if</span> (iteratee == <span class="hljs-literal">null</span> || (<span class="hljs-keyword">typeof</span> iteratee == <span class="hljs-string">&#x27;number&#x27;</span> &amp;&amp; <span class="hljs-keyword">typeof</span> obj[<span class="hljs-number">0</span>] != <span class="hljs-string">&#x27;object&#x27;</span> &amp;&amp; obj != <span class="hljs-literal">null</span>)) {
    obj = <span class="hljs-title function_">isArrayLike</span>(obj) ? obj : <span class="hljs-title function_">values</span>(obj);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = obj.<span class="hljs-property">length</span>; i &lt; length; i++) {
      value = obj[i];
      <span class="hljs-keyword">if</span> (value != <span class="hljs-literal">null</span> &amp;&amp; value &gt; result) {
        result = value;
      }
    }
  } <span class="hljs-keyword">else</span> {
    iteratee = <span class="hljs-title function_">cb</span>(iteratee, context);
    <span class="hljs-title function_">each</span>(obj, <span class="hljs-keyword">function</span>(<span class="hljs-params">v, index, list</span>) {
      computed = <span class="hljs-title function_">iteratee</span>(v, index, list);
      <span class="hljs-keyword">if</span> (computed &gt; lastComputed || (computed === -<span class="hljs-title class_">Infinity</span> &amp;&amp; result === -<span class="hljs-title class_">Infinity</span>)) {
        result = v;
        lastComputed = computed;
      }
    });
  }
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-179">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-179">&#182;</a>
              </div>
              <p>Return the minimum element (or element-based computation).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">min</span>(<span class="hljs-params">obj, iteratee, context</span>) {
  <span class="hljs-keyword">var</span> result = <span class="hljs-title class_">Infinity</span>, lastComputed = <span class="hljs-title class_">Infinity</span>,
      value, computed;
  <span class="hljs-keyword">if</span> (iteratee == <span class="hljs-literal">null</span> || (<span class="hljs-keyword">typeof</span> iteratee == <span class="hljs-string">&#x27;number&#x27;</span> &amp;&amp; <span class="hljs-keyword">typeof</span> obj[<span class="hljs-number">0</span>] != <span class="hljs-string">&#x27;object&#x27;</span> &amp;&amp; obj != <span class="hljs-literal">null</span>)) {
    obj = <span class="hljs-title function_">isArrayLike</span>(obj) ? obj : <span class="hljs-title function_">values</span>(obj);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = obj.<span class="hljs-property">length</span>; i &lt; length; i++) {
      value = obj[i];
      <span class="hljs-keyword">if</span> (value != <span class="hljs-literal">null</span> &amp;&amp; value &lt; result) {
        result = value;
      }
    }
  } <span class="hljs-keyword">else</span> {
    iteratee = <span class="hljs-title function_">cb</span>(iteratee, context);
    <span class="hljs-title function_">each</span>(obj, <span class="hljs-keyword">function</span>(<span class="hljs-params">v, index, list</span>) {
      computed = <span class="hljs-title function_">iteratee</span>(v, index, list);
      <span class="hljs-keyword">if</span> (computed &lt; lastComputed || (computed === <span class="hljs-title class_">Infinity</span> &amp;&amp; result === <span class="hljs-title class_">Infinity</span>)) {
        result = v;
        lastComputed = computed;
      }
    });
  }
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-180">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-180">&#182;</a>
              </div>
              <p>Safely create a real, live array from anything iterable.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> reStrSymbol = <span class="hljs-regexp">/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g</span>;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">toArray</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">if</span> (!obj) <span class="hljs-keyword">return</span> [];
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isArray</span>(obj)) <span class="hljs-keyword">return</span> slice.<span class="hljs-title function_">call</span>(obj);
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isString</span>(obj)) {</pre></div></div>
            
        </li>
        
        
        <li id="section-181">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-181">&#182;</a>
              </div>
              <p>Keep surrogate pair characters together.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">return</span> obj.<span class="hljs-title function_">match</span>(reStrSymbol);
  }
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isArrayLike</span>(obj)) <span class="hljs-keyword">return</span> <span class="hljs-title function_">map</span>(obj, identity);
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">values</span>(obj);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-182">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-182">&#182;</a>
              </div>
              <p>Sample <strong>n</strong> random values from a collection using the modern version of the
<a href="https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle">Fisher-Yates shuffle</a>.
If <strong>n</strong> is not specified, returns a single random element.
The internal <code>guard</code> argument allows it to work with <code>_.map</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">sample</span>(<span class="hljs-params">obj, n, guard</span>) {
  <span class="hljs-keyword">if</span> (n == <span class="hljs-literal">null</span> || guard) {
    <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isArrayLike</span>(obj)) obj = <span class="hljs-title function_">values</span>(obj);
    <span class="hljs-keyword">return</span> obj[<span class="hljs-title function_">random</span>(obj.<span class="hljs-property">length</span> - <span class="hljs-number">1</span>)];
  }
  <span class="hljs-keyword">var</span> sample = <span class="hljs-title function_">toArray</span>(obj);
  <span class="hljs-keyword">var</span> length = <span class="hljs-title function_">getLength</span>(sample);
  n = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">min</span>(n, length), <span class="hljs-number">0</span>);
  <span class="hljs-keyword">var</span> last = length - <span class="hljs-number">1</span>;
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; n; index++) {
    <span class="hljs-keyword">var</span> rand = <span class="hljs-title function_">random</span>(index, last);
    <span class="hljs-keyword">var</span> temp = sample[index];
    sample[index] = sample[rand];
    sample[rand] = temp;
  }
  <span class="hljs-keyword">return</span> sample.<span class="hljs-title function_">slice</span>(<span class="hljs-number">0</span>, n);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-183">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-183">&#182;</a>
              </div>
              <p>Shuffle a collection.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">shuffle</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">sample</span>(obj, <span class="hljs-title class_">Infinity</span>);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-184">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-184">&#182;</a>
              </div>
              <p>Sort the object’s values by a criterion produced by an iteratee.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">sortBy</span>(<span class="hljs-params">obj, iteratee, context</span>) {
  <span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>;
  iteratee = <span class="hljs-title function_">cb</span>(iteratee, context);
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">pluck</span>(<span class="hljs-title function_">map</span>(obj, <span class="hljs-keyword">function</span>(<span class="hljs-params">value, key, list</span>) {
    <span class="hljs-keyword">return</span> {
      <span class="hljs-attr">value</span>: value,
      <span class="hljs-attr">index</span>: index++,
      <span class="hljs-attr">criteria</span>: <span class="hljs-title function_">iteratee</span>(value, key, list)
    };
  }).<span class="hljs-title function_">sort</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">left, right</span>) {
    <span class="hljs-keyword">var</span> a = left.<span class="hljs-property">criteria</span>;
    <span class="hljs-keyword">var</span> b = right.<span class="hljs-property">criteria</span>;
    <span class="hljs-keyword">if</span> (a !== b) {
      <span class="hljs-keyword">if</span> (a &gt; b || a === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
      <span class="hljs-keyword">if</span> (a &lt; b || b === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>;
    }
    <span class="hljs-keyword">return</span> left.<span class="hljs-property">index</span> - right.<span class="hljs-property">index</span>;
  }), <span class="hljs-string">&#x27;value&#x27;</span>);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-185">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-185">&#182;</a>
              </div>
              <p>An internal function used for aggregate “group by” operations.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">group</span>(<span class="hljs-params">behavior, partition</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">obj, iteratee, context</span>) {
    <span class="hljs-keyword">var</span> result = partition ? [[], []] : {};
    iteratee = <span class="hljs-title function_">cb</span>(iteratee, context);
    <span class="hljs-title function_">each</span>(obj, <span class="hljs-keyword">function</span>(<span class="hljs-params">value, index</span>) {
      <span class="hljs-keyword">var</span> key = <span class="hljs-title function_">iteratee</span>(value, index, obj);
      <span class="hljs-title function_">behavior</span>(result, value, key);
    });
    <span class="hljs-keyword">return</span> result;
  };
}</pre></div></div>
            
        </li>
        
        
        <li id="section-186">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-186">&#182;</a>
              </div>
              <p>Groups the object’s values by a criterion. Pass either a string attribute
to group by, or a function that returns the criterion.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> groupBy = <span class="hljs-title function_">group</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">result, value, key</span>) {
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">has$1</span>(result, key)) result[key].<span class="hljs-title function_">push</span>(value); <span class="hljs-keyword">else</span> result[key] = [value];
});</pre></div></div>
            
        </li>
        
        
        <li id="section-187">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-187">&#182;</a>
              </div>
              <p>Indexes the object’s values by a criterion, similar to <code>_.groupBy</code>, but for
when you know that your index values will be unique.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> indexBy = <span class="hljs-title function_">group</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">result, value, key</span>) {
  result[key] = value;
});</pre></div></div>
            
        </li>
        
        
        <li id="section-188">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-188">&#182;</a>
              </div>
              <p>Counts instances of an object that group by a certain criterion. Pass
either a string attribute to count by, or a function that returns the
criterion.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> countBy = <span class="hljs-title function_">group</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">result, value, key</span>) {
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">has$1</span>(result, key)) result[key]++; <span class="hljs-keyword">else</span> result[key] = <span class="hljs-number">1</span>;
});</pre></div></div>
            
        </li>
        
        
        <li id="section-189">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-189">&#182;</a>
              </div>
              <p>Split a collection into two arrays: one whose elements all pass the given
truth test, and one whose elements all do not pass the truth test.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> partition = <span class="hljs-title function_">group</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">result, value, pass</span>) {
  result[pass ? <span class="hljs-number">0</span> : <span class="hljs-number">1</span>].<span class="hljs-title function_">push</span>(value);
}, <span class="hljs-literal">true</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-190">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-190">&#182;</a>
              </div>
              <p>Return the number of elements in a collection.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">size</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">isArrayLike</span>(obj) ? obj.<span class="hljs-property">length</span> : <span class="hljs-title function_">keys</span>(obj).<span class="hljs-property">length</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-191">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-191">&#182;</a>
              </div>
              <p>Internal <code>_.pick</code> helper function to determine whether <code>key</code> is an enumerable
property name of <code>obj</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">keyInObj</span>(<span class="hljs-params">value, key, obj</span>) {
  <span class="hljs-keyword">return</span> key <span class="hljs-keyword">in</span> obj;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-192">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-192">&#182;</a>
              </div>
              <p>Return a copy of the object only containing the allowed properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> pick = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">obj, keys</span>) {
  <span class="hljs-keyword">var</span> result = {}, iteratee = keys[<span class="hljs-number">0</span>];
  <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> result;
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isFunction$1</span>(iteratee)) {
    <span class="hljs-keyword">if</span> (keys.<span class="hljs-property">length</span> &gt; <span class="hljs-number">1</span>) iteratee = <span class="hljs-title function_">optimizeCb</span>(iteratee, keys[<span class="hljs-number">1</span>]);
    keys = <span class="hljs-title function_">allKeys</span>(obj);
  } <span class="hljs-keyword">else</span> {
    iteratee = keyInObj;
    keys = <span class="hljs-title function_">flatten$1</span>(keys, <span class="hljs-literal">false</span>, <span class="hljs-literal">false</span>);
    obj = <span class="hljs-title class_">Object</span>(obj);
  }
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = keys.<span class="hljs-property">length</span>; i &lt; length; i++) {
    <span class="hljs-keyword">var</span> key = keys[i];
    <span class="hljs-keyword">var</span> value = obj[key];
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">iteratee</span>(value, key, obj)) result[key] = value;
  }
  <span class="hljs-keyword">return</span> result;
});</pre></div></div>
            
        </li>
        
        
        <li id="section-193">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-193">&#182;</a>
              </div>
              <p>Return a copy of the object without the disallowed properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> omit = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">obj, keys</span>) {
  <span class="hljs-keyword">var</span> iteratee = keys[<span class="hljs-number">0</span>], context;
  <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isFunction$1</span>(iteratee)) {
    iteratee = <span class="hljs-title function_">negate</span>(iteratee);
    <span class="hljs-keyword">if</span> (keys.<span class="hljs-property">length</span> &gt; <span class="hljs-number">1</span>) context = keys[<span class="hljs-number">1</span>];
  } <span class="hljs-keyword">else</span> {
    keys = <span class="hljs-title function_">map</span>(<span class="hljs-title function_">flatten$1</span>(keys, <span class="hljs-literal">false</span>, <span class="hljs-literal">false</span>), <span class="hljs-title class_">String</span>);
    iteratee = <span class="hljs-keyword">function</span>(<span class="hljs-params">value, key</span>) {
      <span class="hljs-keyword">return</span> !<span class="hljs-title function_">contains</span>(keys, key);
    };
  }
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">pick</span>(obj, iteratee, context);
});</pre></div></div>
            
        </li>
        
        
        <li id="section-194">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-194">&#182;</a>
              </div>
              <p>Returns everything but the last entry of the array. Especially useful on
the arguments object. Passing <strong>n</strong> will return all the values in
the array, excluding the last N.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">initial</span>(<span class="hljs-params">array, n, guard</span>) {
  <span class="hljs-keyword">return</span> slice.<span class="hljs-title function_">call</span>(array, <span class="hljs-number">0</span>, <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(<span class="hljs-number">0</span>, array.<span class="hljs-property">length</span> - (n == <span class="hljs-literal">null</span> || guard ? <span class="hljs-number">1</span> : n)));
}</pre></div></div>
            
        </li>
        
        
        <li id="section-195">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-195">&#182;</a>
              </div>
              <p>Get the first element of an array. Passing <strong>n</strong> will return the first N
values in the array. The <strong>guard</strong> check allows it to work with <code>_.map</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">first</span>(<span class="hljs-params">array, n, guard</span>) {
  <span class="hljs-keyword">if</span> (array == <span class="hljs-literal">null</span> || array.<span class="hljs-property">length</span> &lt; <span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> n == <span class="hljs-literal">null</span> || guard ? <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> : [];
  <span class="hljs-keyword">if</span> (n == <span class="hljs-literal">null</span> || guard) <span class="hljs-keyword">return</span> array[<span class="hljs-number">0</span>];
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">initial</span>(array, array.<span class="hljs-property">length</span> - n);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-196">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-196">&#182;</a>
              </div>
              <p>Returns everything but the first entry of the <code>array</code>. Especially useful on
the <code>arguments</code> object. Passing an <strong>n</strong> will return the rest N values in the
<code>array</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">rest</span>(<span class="hljs-params">array, n, guard</span>) {
  <span class="hljs-keyword">return</span> slice.<span class="hljs-title function_">call</span>(array, n == <span class="hljs-literal">null</span> || guard ? <span class="hljs-number">1</span> : n);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-197">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-197">&#182;</a>
              </div>
              <p>Get the last element of an array. Passing <strong>n</strong> will return the last N
values in the array.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">last</span>(<span class="hljs-params">array, n, guard</span>) {
  <span class="hljs-keyword">if</span> (array == <span class="hljs-literal">null</span> || array.<span class="hljs-property">length</span> &lt; <span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> n == <span class="hljs-literal">null</span> || guard ? <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> : [];
  <span class="hljs-keyword">if</span> (n == <span class="hljs-literal">null</span> || guard) <span class="hljs-keyword">return</span> array[array.<span class="hljs-property">length</span> - <span class="hljs-number">1</span>];
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">rest</span>(array, <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(<span class="hljs-number">0</span>, array.<span class="hljs-property">length</span> - n));
}</pre></div></div>
            
        </li>
        
        
        <li id="section-198">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-198">&#182;</a>
              </div>
              <p>Trim out all falsy values from an array.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">compact</span>(<span class="hljs-params">array</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">filter</span>(array, <span class="hljs-title class_">Boolean</span>);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-199">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-199">&#182;</a>
              </div>
              <p>Flatten out an array, either recursively (by default), or up to <code>depth</code>.
Passing <code>true</code> or <code>false</code> as <code>depth</code> means <code>1</code> or <code>Infinity</code>, respectively.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">flatten</span>(<span class="hljs-params">array, depth</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">flatten$1</span>(array, depth, <span class="hljs-literal">false</span>);
}</pre></div></div>
            
        </li>
        
        
        <li id="section-200">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-200">&#182;</a>
              </div>
              <p>Take the difference between one array and a number of other arrays.
Only the elements present in just the first array will remain.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> difference = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">array, rest</span>) {
  rest = <span class="hljs-title function_">flatten$1</span>(rest, <span class="hljs-literal">true</span>, <span class="hljs-literal">true</span>);
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">filter</span>(array, <span class="hljs-keyword">function</span>(<span class="hljs-params">value</span>){
    <span class="hljs-keyword">return</span> !<span class="hljs-title function_">contains</span>(rest, value);
  });
});</pre></div></div>
            
        </li>
        
        
        <li id="section-201">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-201">&#182;</a>
              </div>
              <p>Return a version of the array that does not contain the specified value(s).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> without = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">array, otherArrays</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">difference</span>(array, otherArrays);
});</pre></div></div>
            
        </li>
        
        
        <li id="section-202">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-202">&#182;</a>
              </div>
              <p>Produce a duplicate-free version of the array. If the array has already
been sorted, you have the option of using a faster algorithm.
The faster algorithm will not work with an iteratee if the iteratee
is not a one-to-one function, so providing an iteratee will disable
the faster algorithm.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">uniq</span>(<span class="hljs-params">array, isSorted, iteratee, context</span>) {
  <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">isBoolean</span>(isSorted)) {
    context = iteratee;
    iteratee = isSorted;
    isSorted = <span class="hljs-literal">false</span>;
  }
  <span class="hljs-keyword">if</span> (iteratee != <span class="hljs-literal">null</span>) iteratee = <span class="hljs-title function_">cb</span>(iteratee, context);
  <span class="hljs-keyword">var</span> result = [];
  <span class="hljs-keyword">var</span> seen = [];
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = <span class="hljs-title function_">getLength</span>(array); i &lt; length; i++) {
    <span class="hljs-keyword">var</span> value = array[i],
        computed = iteratee ? <span class="hljs-title function_">iteratee</span>(value, i, array) : value;
    <span class="hljs-keyword">if</span> (isSorted &amp;&amp; !iteratee) {
      <span class="hljs-keyword">if</span> (!i || seen !== computed) result.<span class="hljs-title function_">push</span>(value);
      seen = computed;
    } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (iteratee) {
      <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">contains</span>(seen, computed)) {
        seen.<span class="hljs-title function_">push</span>(computed);
        result.<span class="hljs-title function_">push</span>(value);
      }
    } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">contains</span>(result, value)) {
      result.<span class="hljs-title function_">push</span>(value);
    }
  }
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-203">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-203">&#182;</a>
              </div>
              <p>Produce an array that contains the union: each distinct element from all of
the passed-in arrays.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> union = <span class="hljs-title function_">restArguments</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params">arrays</span>) {
  <span class="hljs-keyword">return</span> <span class="hljs-title function_">uniq</span>(<span class="hljs-title function_">flatten$1</span>(arrays, <span class="hljs-literal">true</span>, <span class="hljs-literal">true</span>));
});</pre></div></div>
            
        </li>
        
        
        <li id="section-204">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-204">&#182;</a>
              </div>
              <p>Produce an array that contains every item shared between all the
passed-in arrays.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">intersection</span>(<span class="hljs-params">array</span>) {
  <span class="hljs-keyword">var</span> result = [];
  <span class="hljs-keyword">var</span> argsLength = <span class="hljs-variable language_">arguments</span>.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = <span class="hljs-title function_">getLength</span>(array); i &lt; length; i++) {
    <span class="hljs-keyword">var</span> item = array[i];
    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">contains</span>(result, item)) <span class="hljs-keyword">continue</span>;
    <span class="hljs-keyword">var</span> j;
    <span class="hljs-keyword">for</span> (j = <span class="hljs-number">1</span>; j &lt; argsLength; j++) {
      <span class="hljs-keyword">if</span> (!<span class="hljs-title function_">contains</span>(<span class="hljs-variable language_">arguments</span>[j], item)) <span class="hljs-keyword">break</span>;
    }
    <span class="hljs-keyword">if</span> (j === argsLength) result.<span class="hljs-title function_">push</span>(item);
  }
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-205">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-205">&#182;</a>
              </div>
              <p>Complement of zip. Unzip accepts an array of arrays and groups
each array’s elements on shared indices.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">unzip</span>(<span class="hljs-params">array</span>) {
  <span class="hljs-keyword">var</span> length = (array &amp;&amp; <span class="hljs-title function_">max</span>(array, getLength).<span class="hljs-property">length</span>) || <span class="hljs-number">0</span>;
  <span class="hljs-keyword">var</span> result = <span class="hljs-title class_">Array</span>(length);

  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
    result[index] = <span class="hljs-title function_">pluck</span>(array, index);
  }
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-206">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-206">&#182;</a>
              </div>
              <p>Zip together multiple lists into a single array – elements that share
an index go together.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> zip = <span class="hljs-title function_">restArguments</span>(unzip);</pre></div></div>
            
        </li>
        
        
        <li id="section-207">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-207">&#182;</a>
              </div>
              <p>Converts lists into objects. Pass either a single array of <code>[key, value]</code>
pairs, or two parallel arrays of the same length – one of keys, and one of
the corresponding values. Passing by pairs is the reverse of <code>_.pairs</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">object</span>(<span class="hljs-params">list, values</span>) {
  <span class="hljs-keyword">var</span> result = {};
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = <span class="hljs-title function_">getLength</span>(list); i &lt; length; i++) {
    <span class="hljs-keyword">if</span> (values) {
      result[list[i]] = values[i];
    } <span class="hljs-keyword">else</span> {
      result[list[i][<span class="hljs-number">0</span>]] = list[i][<span class="hljs-number">1</span>];
    }
  }
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-208">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-208">&#182;</a>
              </div>
              <p>Generate an integer Array containing an arithmetic progression. A port of
the native Python <code>range()</code> function. See
<a href="https://docs.python.org/library/functions.html#range">the Python documentation</a>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">range</span>(<span class="hljs-params">start, stop, step</span>) {
  <span class="hljs-keyword">if</span> (stop == <span class="hljs-literal">null</span>) {
    stop = start || <span class="hljs-number">0</span>;
    start = <span class="hljs-number">0</span>;
  }
  <span class="hljs-keyword">if</span> (!step) {
    step = stop &lt; start ? -<span class="hljs-number">1</span> : <span class="hljs-number">1</span>;
  }

  <span class="hljs-keyword">var</span> length = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">ceil</span>((stop - start) / step), <span class="hljs-number">0</span>);
  <span class="hljs-keyword">var</span> range = <span class="hljs-title class_">Array</span>(length);

  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> idx = <span class="hljs-number">0</span>; idx &lt; length; idx++, start += step) {
    range[idx] = start;
  }

  <span class="hljs-keyword">return</span> range;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-209">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-209">&#182;</a>
              </div>
              <p>Chunk a single array into multiple arrays, each containing <code>count</code> or fewer
items.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">chunk</span>(<span class="hljs-params">array, count</span>) {
  <span class="hljs-keyword">if</span> (count == <span class="hljs-literal">null</span> || count &lt; <span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> [];
  <span class="hljs-keyword">var</span> result = [];
  <span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = array.<span class="hljs-property">length</span>;
  <span class="hljs-keyword">while</span> (i &lt; length) {
    result.<span class="hljs-title function_">push</span>(slice.<span class="hljs-title function_">call</span>(array, i, i += count));
  }
  <span class="hljs-keyword">return</span> result;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-210">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-210">&#182;</a>
              </div>
              <p>Helper function to continue chaining intermediate results.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">chainResult</span>(<span class="hljs-params">instance, obj</span>) {
  <span class="hljs-keyword">return</span> instance.<span class="hljs-property">_chain</span> ? <span class="hljs-title function_">_$1</span>(obj).<span class="hljs-title function_">chain</span>() : obj;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-211">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-211">&#182;</a>
              </div>
              <p>Add your own custom functions to the Underscore object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">function</span> <span class="hljs-title function_">mixin</span>(<span class="hljs-params">obj</span>) {
  <span class="hljs-title function_">each</span>(<span class="hljs-title function_">functions</span>(obj), <span class="hljs-keyword">function</span>(<span class="hljs-params">name</span>) {
    <span class="hljs-keyword">var</span> func = _$<span class="hljs-number">1</span>[name] = obj[name];
    _$<span class="hljs-number">1.</span>prototype[name] = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
      <span class="hljs-keyword">var</span> args = [<span class="hljs-variable language_">this</span>.<span class="hljs-property">_wrapped</span>];
      push.<span class="hljs-title function_">apply</span>(args, <span class="hljs-variable language_">arguments</span>);
      <span class="hljs-keyword">return</span> <span class="hljs-title function_">chainResult</span>(<span class="hljs-variable language_">this</span>, func.<span class="hljs-title function_">apply</span>(_$<span class="hljs-number">1</span>, args));
    };
  });
  <span class="hljs-keyword">return</span> _$<span class="hljs-number">1</span>;
}</pre></div></div>
            
        </li>
        
        
        <li id="section-212">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-212">&#182;</a>
              </div>
              <p>Add all mutator <code>Array</code> functions to the wrapper.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-title function_">each</span>([<span class="hljs-string">&#x27;pop&#x27;</span>, <span class="hljs-string">&#x27;push&#x27;</span>, <span class="hljs-string">&#x27;reverse&#x27;</span>, <span class="hljs-string">&#x27;shift&#x27;</span>, <span class="hljs-string">&#x27;sort&#x27;</span>, <span class="hljs-string">&#x27;splice&#x27;</span>, <span class="hljs-string">&#x27;unshift&#x27;</span>], <span class="hljs-keyword">function</span>(<span class="hljs-params">name</span>) {
  <span class="hljs-keyword">var</span> method = <span class="hljs-title class_">ArrayProto</span>[name];
  _$<span class="hljs-number">1.</span>prototype[name] = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">var</span> obj = <span class="hljs-variable language_">this</span>.<span class="hljs-property">_wrapped</span>;
    <span class="hljs-keyword">if</span> (obj != <span class="hljs-literal">null</span>) {
      method.<span class="hljs-title function_">apply</span>(obj, <span class="hljs-variable language_">arguments</span>);
      <span class="hljs-keyword">if</span> ((name === <span class="hljs-string">&#x27;shift&#x27;</span> || name === <span class="hljs-string">&#x27;splice&#x27;</span>) &amp;&amp; obj.<span class="hljs-property">length</span> === <span class="hljs-number">0</span>) {
        <span class="hljs-keyword">delete</span> obj[<span class="hljs-number">0</span>];
      }
    }
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">chainResult</span>(<span class="hljs-variable language_">this</span>, obj);
  };
});</pre></div></div>
            
        </li>
        
        
        <li id="section-213">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-213">&#182;</a>
              </div>
              <p>Add all accessor <code>Array</code> functions to the wrapper.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-title function_">each</span>([<span class="hljs-string">&#x27;concat&#x27;</span>, <span class="hljs-string">&#x27;join&#x27;</span>, <span class="hljs-string">&#x27;slice&#x27;</span>], <span class="hljs-keyword">function</span>(<span class="hljs-params">name</span>) {
  <span class="hljs-keyword">var</span> method = <span class="hljs-title class_">ArrayProto</span>[name];
  _$<span class="hljs-number">1.</span>prototype[name] = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
    <span class="hljs-keyword">var</span> obj = <span class="hljs-variable language_">this</span>.<span class="hljs-property">_wrapped</span>;
    <span class="hljs-keyword">if</span> (obj != <span class="hljs-literal">null</span>) obj = method.<span class="hljs-title function_">apply</span>(obj, <span class="hljs-variable language_">arguments</span>);
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">chainResult</span>(<span class="hljs-variable language_">this</span>, obj);
  };
});</pre></div></div>
            
        </li>
        
        
        <li id="section-214">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-214">&#182;</a>
              </div>
              <p>Named Exports</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>
<span class="hljs-keyword">var</span> allExports = {
  <span class="hljs-attr">__proto__</span>: <span class="hljs-literal">null</span>,
  <span class="hljs-attr">VERSION</span>: <span class="hljs-variable constant_">VERSION</span>,
  <span class="hljs-attr">restArguments</span>: restArguments,
  <span class="hljs-attr">isObject</span>: isObject,
  <span class="hljs-attr">isNull</span>: isNull,
  <span class="hljs-attr">isUndefined</span>: isUndefined,
  <span class="hljs-attr">isBoolean</span>: isBoolean,
  <span class="hljs-attr">isElement</span>: isElement,
  <span class="hljs-attr">isString</span>: isString,
  <span class="hljs-attr">isNumber</span>: isNumber,
  <span class="hljs-attr">isDate</span>: isDate,
  <span class="hljs-attr">isRegExp</span>: isRegExp,
  <span class="hljs-attr">isError</span>: isError,
  <span class="hljs-attr">isSymbol</span>: isSymbol,
  <span class="hljs-attr">isArrayBuffer</span>: isArrayBuffer,
  <span class="hljs-attr">isDataView</span>: isDataView$<span class="hljs-number">1</span>,
  <span class="hljs-attr">isArray</span>: isArray,
  <span class="hljs-attr">isFunction</span>: isFunction$<span class="hljs-number">1</span>,
  <span class="hljs-attr">isArguments</span>: isArguments$<span class="hljs-number">1</span>,
  <span class="hljs-attr">isFinite</span>: isFinite$<span class="hljs-number">1</span>,
  <span class="hljs-attr">isNaN</span>: isNaN$<span class="hljs-number">1</span>,
  <span class="hljs-attr">isTypedArray</span>: isTypedArray$<span class="hljs-number">1</span>,
  <span class="hljs-attr">isEmpty</span>: isEmpty,
  <span class="hljs-attr">isMatch</span>: isMatch,
  <span class="hljs-attr">isEqual</span>: isEqual,
  <span class="hljs-attr">isMap</span>: isMap,
  <span class="hljs-attr">isWeakMap</span>: isWeakMap,
  <span class="hljs-attr">isSet</span>: isSet,
  <span class="hljs-attr">isWeakSet</span>: isWeakSet,
  <span class="hljs-attr">keys</span>: keys,
  <span class="hljs-attr">allKeys</span>: allKeys,
  <span class="hljs-attr">values</span>: values,
  <span class="hljs-attr">pairs</span>: pairs,
  <span class="hljs-attr">invert</span>: invert,
  <span class="hljs-attr">functions</span>: functions,
  <span class="hljs-attr">methods</span>: functions,
  <span class="hljs-attr">extend</span>: extend,
  <span class="hljs-attr">extendOwn</span>: extendOwn,
  <span class="hljs-attr">assign</span>: extendOwn,
  <span class="hljs-attr">defaults</span>: defaults,
  <span class="hljs-attr">create</span>: create,
  <span class="hljs-attr">clone</span>: clone,
  <span class="hljs-attr">tap</span>: tap,
  <span class="hljs-attr">get</span>: get,
  <span class="hljs-attr">has</span>: has,
  <span class="hljs-attr">mapObject</span>: mapObject,
  <span class="hljs-attr">identity</span>: identity,
  <span class="hljs-attr">constant</span>: constant,
  <span class="hljs-attr">noop</span>: noop,
  <span class="hljs-attr">toPath</span>: toPath$<span class="hljs-number">1</span>,
  <span class="hljs-attr">property</span>: property,
  <span class="hljs-attr">propertyOf</span>: propertyOf,
  <span class="hljs-attr">matcher</span>: matcher,
  <span class="hljs-attr">matches</span>: matcher,
  <span class="hljs-attr">times</span>: times,
  <span class="hljs-attr">random</span>: random,
  <span class="hljs-attr">now</span>: now,
  <span class="hljs-attr">escape</span>: _escape,
  <span class="hljs-attr">unescape</span>: _unescape,
  <span class="hljs-attr">templateSettings</span>: templateSettings,
  <span class="hljs-attr">template</span>: template,
  <span class="hljs-attr">result</span>: result,
  <span class="hljs-attr">uniqueId</span>: uniqueId,
  <span class="hljs-attr">chain</span>: chain,
  <span class="hljs-attr">iteratee</span>: iteratee,
  <span class="hljs-attr">partial</span>: partial,
  <span class="hljs-attr">bind</span>: bind,
  <span class="hljs-attr">bindAll</span>: bindAll,
  <span class="hljs-attr">memoize</span>: memoize,
  <span class="hljs-attr">delay</span>: delay,
  <span class="hljs-attr">defer</span>: defer,
  <span class="hljs-attr">throttle</span>: throttle,
  <span class="hljs-attr">debounce</span>: debounce,
  <span class="hljs-attr">wrap</span>: wrap,
  <span class="hljs-attr">negate</span>: negate,
  <span class="hljs-attr">compose</span>: compose,
  <span class="hljs-attr">after</span>: after,
  <span class="hljs-attr">before</span>: before,
  <span class="hljs-attr">once</span>: once,
  <span class="hljs-attr">findKey</span>: findKey,
  <span class="hljs-attr">findIndex</span>: findIndex,
  <span class="hljs-attr">findLastIndex</span>: findLastIndex,
  <span class="hljs-attr">sortedIndex</span>: sortedIndex,
  <span class="hljs-attr">indexOf</span>: indexOf,
  <span class="hljs-attr">lastIndexOf</span>: lastIndexOf,
  <span class="hljs-attr">find</span>: find,
  <span class="hljs-attr">detect</span>: find,
  <span class="hljs-attr">findWhere</span>: findWhere,
  <span class="hljs-attr">each</span>: each,
  <span class="hljs-attr">forEach</span>: each,
  <span class="hljs-attr">map</span>: map,
  <span class="hljs-attr">collect</span>: map,
  <span class="hljs-attr">reduce</span>: reduce,
  <span class="hljs-attr">foldl</span>: reduce,
  <span class="hljs-attr">inject</span>: reduce,
  <span class="hljs-attr">reduceRight</span>: reduceRight,
  <span class="hljs-attr">foldr</span>: reduceRight,
  <span class="hljs-attr">filter</span>: filter,
  <span class="hljs-attr">select</span>: filter,
  <span class="hljs-attr">reject</span>: reject,
  <span class="hljs-attr">every</span>: every,
  <span class="hljs-attr">all</span>: every,
  <span class="hljs-attr">some</span>: some,
  <span class="hljs-attr">any</span>: some,
  <span class="hljs-attr">contains</span>: contains,
  <span class="hljs-attr">includes</span>: contains,
  <span class="hljs-attr">include</span>: contains,
  <span class="hljs-attr">invoke</span>: invoke,
  <span class="hljs-attr">pluck</span>: pluck,
  <span class="hljs-attr">where</span>: where,
  <span class="hljs-attr">max</span>: max,
  <span class="hljs-attr">min</span>: min,
  <span class="hljs-attr">shuffle</span>: shuffle,
  <span class="hljs-attr">sample</span>: sample,
  <span class="hljs-attr">sortBy</span>: sortBy,
  <span class="hljs-attr">groupBy</span>: groupBy,
  <span class="hljs-attr">indexBy</span>: indexBy,
  <span class="hljs-attr">countBy</span>: countBy,
  <span class="hljs-attr">partition</span>: partition,
  <span class="hljs-attr">toArray</span>: toArray,
  <span class="hljs-attr">size</span>: size,
  <span class="hljs-attr">pick</span>: pick,
  <span class="hljs-attr">omit</span>: omit,
  <span class="hljs-attr">first</span>: first,
  <span class="hljs-attr">head</span>: first,
  <span class="hljs-attr">take</span>: first,
  <span class="hljs-attr">initial</span>: initial,
  <span class="hljs-attr">last</span>: last,
  <span class="hljs-attr">rest</span>: rest,
  <span class="hljs-attr">tail</span>: rest,
  <span class="hljs-attr">drop</span>: rest,
  <span class="hljs-attr">compact</span>: compact,
  <span class="hljs-attr">flatten</span>: flatten,
  <span class="hljs-attr">without</span>: without,
  <span class="hljs-attr">uniq</span>: uniq,
  <span class="hljs-attr">unique</span>: uniq,
  <span class="hljs-attr">union</span>: union,
  <span class="hljs-attr">intersection</span>: intersection,
  <span class="hljs-attr">difference</span>: difference,
  <span class="hljs-attr">unzip</span>: unzip,
  <span class="hljs-attr">transpose</span>: unzip,
  <span class="hljs-attr">zip</span>: zip,
  <span class="hljs-attr">object</span>: object,
  <span class="hljs-attr">range</span>: range,
  <span class="hljs-attr">chunk</span>: chunk,
  <span class="hljs-attr">mixin</span>: mixin,
  <span class="hljs-string">&#x27;default&#x27;</span>: _$<span class="hljs-number">1</span>
};</pre></div></div>
            
        </li>
        
        
        <li id="section-215">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-215">&#182;</a>
              </div>
              <p>Default Export</p>

            </div>
            
        </li>
        
        
        <li id="section-216">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-216">&#182;</a>
              </div>
              <p>Add all of the Underscore functions to the wrapper object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> _ = <span class="hljs-title function_">mixin</span>(allExports);</pre></div></div>
            
        </li>
        
        
        <li id="section-217">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-217">&#182;</a>
              </div>
              <p>Legacy Node.js API.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>_.<span class="hljs-property">_</span> = _;</pre></div></div>
            
        </li>
        
        
        <li id="section-218">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-218">&#182;</a>
              </div>
              <p>ESM Exports</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>
<span class="hljs-keyword">export</span> <span class="hljs-keyword">default</span> _;
<span class="hljs-keyword">export</span> { <span class="hljs-variable constant_">VERSION</span>, after, every <span class="hljs-keyword">as</span> all, allKeys, some <span class="hljs-keyword">as</span> any, extendOwn <span class="hljs-keyword">as</span> assign, before, bind, bindAll, chain, chunk, clone, map <span class="hljs-keyword">as</span> collect, compact, compose, constant, contains, countBy, create, debounce, defaults, defer, delay, find <span class="hljs-keyword">as</span> detect, difference, rest <span class="hljs-keyword">as</span> drop, each, _escape <span class="hljs-keyword">as</span> <span class="hljs-built_in">escape</span>, every, extend, extendOwn, filter, find, findIndex, findKey, findLastIndex, findWhere, first, flatten, reduce <span class="hljs-keyword">as</span> foldl, reduceRight <span class="hljs-keyword">as</span> foldr, each <span class="hljs-keyword">as</span> forEach, functions, get, groupBy, has, first <span class="hljs-keyword">as</span> head, identity, contains <span class="hljs-keyword">as</span> include, contains <span class="hljs-keyword">as</span> includes, indexBy, indexOf, initial, reduce <span class="hljs-keyword">as</span> inject, intersection, invert, invoke, isArguments$<span class="hljs-number">1</span> <span class="hljs-keyword">as</span> isArguments, isArray, isArrayBuffer, isBoolean, isDataView$<span class="hljs-number">1</span> <span class="hljs-keyword">as</span> isDataView, isDate, isElement, isEmpty, isEqual, isError, isFinite$<span class="hljs-number">1</span> <span class="hljs-keyword">as</span> <span class="hljs-built_in">isFinite</span>, isFunction$<span class="hljs-number">1</span> <span class="hljs-keyword">as</span> isFunction, isMap, isMatch, isNaN$<span class="hljs-number">1</span> <span class="hljs-keyword">as</span> <span class="hljs-built_in">isNaN</span>, isNull, isNumber, isObject, isRegExp, isSet, isString, isSymbol, isTypedArray$<span class="hljs-number">1</span> <span class="hljs-keyword">as</span> isTypedArray, isUndefined, isWeakMap, isWeakSet, iteratee, keys, last, lastIndexOf, map, mapObject, matcher, matcher <span class="hljs-keyword">as</span> matches, max, memoize, functions <span class="hljs-keyword">as</span> methods, min, mixin, negate, noop, now, object, omit, once, pairs, partial, partition, pick, pluck, property, propertyOf, random, range, reduce, reduceRight, reject, rest, restArguments, result, sample, filter <span class="hljs-keyword">as</span> select, shuffle, size, some, sortBy, sortedIndex, rest <span class="hljs-keyword">as</span> tail, first <span class="hljs-keyword">as</span> take, tap, template, templateSettings, throttle, times, toArray, toPath$<span class="hljs-number">1</span> <span class="hljs-keyword">as</span> toPath, unzip <span class="hljs-keyword">as</span> transpose, _unescape <span class="hljs-keyword">as</span> <span class="hljs-built_in">unescape</span>, union, uniq, uniq <span class="hljs-keyword">as</span> unique, uniqueId, unzip, values, where, without, wrap, zip };</pre></div></div>
            
        </li>
        
        
        <li id="section-219">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-219">&#182;</a>
              </div>
              <h1 id="sourcemappingurlunderscore-esmjsmap">sourceMappingURL=underscore-esm.js.map</h1>

            </div>
            
        </li>
        
    </ul>
  </div>
</body>
</html>
